diff options
Diffstat (limited to 'WebKit/chromium')
338 files changed, 62694 insertions, 0 deletions
diff --git a/WebKit/chromium/ChangeLog b/WebKit/chromium/ChangeLog new file mode 100644 index 0000000..9cd3644 --- /dev/null +++ b/WebKit/chromium/ChangeLog @@ -0,0 +1,6679 @@ +2010-02-12 Jeremy Orlow <jorlow@chromium.org> + + Reviewed by Darin Fisher. + + [Chromium] Add a blockedByPolicy output to WebStorageArea::setItem. + https://bugs.webkit.org/show_bug.cgi?id=34897 + + * public/WebStorageArea.h: + (WebKit::WebStorageArea::setItem): + * src/WebStorageAreaImpl.cpp: + (WebKit::WebStorageAreaImpl::setItem): + * src/WebStorageAreaImpl.h: + +2010-02-11 Jeremy Orlow <jorlow@chromium.org> + + Reviewed by David Levin. + + [Chromium] Add ENABLE_RUBY to the feature defines gypi + https://bugs.webkit.org/show_bug.cgi?id=34841 + + * features.gypi: + +2010-02-12 Yury Semikhatsky <yurys@chromium.org> + + Reviewed by Pavel Feldman. + + Chromium: Web Inspector on an element in a page where JS is blocked crashes the renderer + + https://bugs.webkit.org/show_bug.cgi?id=34890 + + * src/DebuggerAgentImpl.cpp: + (WebKit::DebuggerAgentImpl::createUtilityContext): + +2010-02-11 Mikhail Naganov <mnaganov@chromium.org> + + Reviewed by Pavel Feldman. + + [Chromium] Ignore subsequent requests of the same profiler log + chunks. This eliminates emission of several instances for the same + heap snapshot. + + https://bugs.webkit.org/show_bug.cgi?id=34833 + + * src/js/ProfilerAgent.js: + (devtools.ProfilerAgent): + (devtools.ProfilerAgent.prototype.initializeProfiling): + (devtools.ProfilerAgent.prototype._getNextLogLines): + (devtools.ProfilerAgent.prototype.startProfiling): + (devtools.ProfilerAgent.prototype._didGetActiveProfilerModules): + (devtools.ProfilerAgent.prototype._didGetLogLines): + +2010-02-10 James Hawkins <jhawkins@chromium.org> + + Reviewed by Eric Seidel. + + [Chromium] Remove code from SuggestionsPopup that was removed in a + previous revision of AutocompletePopup and accidentally added back in + the refactoring. + + https://bugs.webkit.org/show_bug.cgi?id=34818 + + * src/AutoFillPopupMenuClient.cpp: + * src/AutoFillPopupMenuClient.h: Added property svn:eol-style. + * src/SuggestionsPopupMenuClient.cpp: + (WebKit::SuggestionsPopupMenuClient::popupDidHide): + (WebKit::SuggestionsPopupMenuClient::setTextFromItem): + (WebKit::SuggestionsPopupMenuClient::initialize): + * src/SuggestionsPopupMenuClient.h: + +2010-02-10 Nate Chapin <japhet@chromium.org> + + Reviewed by Adam Barth. + + Update call to V8DOMWrapper::lookupDOMWrapper() to match new parameters. + + https://bugs.webkit.org/show_bug.cgi?id=34768 + + * src/DebuggerAgentImpl.cpp: + (WebKit::DebuggerAgentImpl::createUtilityContext): + +2010-02-10 Kenneth Russell <kbr@google.com> + + Reviewed by Oliver Hunt. + + Remove automatic viewport resizing + https://bugs.webkit.org/show_bug.cgi?id=34766 + + Removed automatic viewport resizing per conclusions on the WebGL + mailing list. Added test verifying new behavior and updated a + couple of previous tests failing after this change. + + * src/GraphicsContext3D.cpp: + (WebCore::GraphicsContext3DInternal::reshape): + +2010-02-10 Yury Semikhatsky <yurys@chromium.org> + + Reviewed by Pavel Feldman. + + Chromium Win build fix. Add third_party/nss to the dependencies list on Windows. + + https://bugs.webkit.org/show_bug.cgi?id=34789 + + * DEPS: + +2010-02-10 Yury Semikhatsky <yurys@chromium.org> + + Reviewed by Pavel Feldman. + + Rolling Chromium dependencies to match Chromium revision 38580. + + https://bugs.webkit.org/show_bug.cgi?id=34789 + + * DEPS: + +2010-02-10 Yury Semikhatsky <yurys@chromium.org> + + Reviewed by Pavel Feldman. + + Use v8::Debug::ProcessDebugMessages instead of executing an empty function + + https://bugs.webkit.org/show_bug.cgi?id=34704 + + * src/DebuggerAgent.h: + * src/DebuggerAgentImpl.cpp: + (WebKit::DebuggerAgentImpl::processDebugCommands): + * src/DebuggerAgentImpl.h: + * src/ToolsAgent.h: + * src/WebDevToolsAgentImpl.cpp: + * src/WebDevToolsAgentImpl.h: + * src/js/DebuggerAgent.js: + (devtools.DebuggerAgent.prototype.addBreakpoint): + * src/js/DevToolsHostStub.js: + (.RemoteDebuggerAgentStub.prototype.processDebugCommands): + * src/js/InjectDispatch.js: + (dispatch): + * src/js/ProfilerAgent.js: + (devtools.ProfilerAgent.prototype.startProfiling): + (devtools.ProfilerAgent.prototype.stopProfiling): + * src/js/Tests.js: + +2010-02-10 Tony Chang <tony@chromium.org> + + Unreviewed, build fix for Chromium Mac take 2. + + * src/AutoFillPopupMenuClient.cpp: + (WebKit::AutoFillPopupMenuClient::removeSuggestionAtIndex): + +2010-02-10 Tony Chang <tony@chromium.org> + + Unreviewed, build fix for Chromium Mac. + + * src/AutoFillPopupMenuClient.cpp: + (WebKit::AutoFillPopupMenuClient::removeSuggestionAtIndex): + +2010-02-09 James Hawkins <jhawkins@chromium.org> + + Reviewed by Darin Fisher. + + [Chromium] Refactor AutocompletePopupMenuClient into a base class, + SuggestionsPopupMenuClient, and two derived classes, + AutocompletePopupMenuClient and AutoFillPopupMenuClient. Currently + the behavior of suggestions popups has not changed. + + https://bugs.webkit.org/show_bug.cgi?id=34721 + + * WebKit.gyp: + * public/WebView.h: + * src/AutoFillPopupMenuClient.cpp: Added. + * src/AutoFillPopupMenuClient.h: Added. + * src/AutocompletePopupMenuClient.cpp: + (WebKit::AutocompletePopupMenuClient::getSuggestionsCount): + (WebKit::AutocompletePopupMenuClient::getSuggestion): + (WebKit::AutocompletePopupMenuClient::removeSuggestionAtIndex): + (WebKit::AutocompletePopupMenuClient::initialize): + (WebKit::AutocompletePopupMenuClient::setSuggestions): + * src/AutocompletePopupMenuClient.h: + * src/SuggestionsPopupMenuClient.cpp: Added. + * src/SuggestionsPopupMenuClient.h: Added. + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::WebViewImpl): + (WebKit::WebViewImpl::keyEvent): + (WebKit::WebViewImpl::autocompleteHandleKeyEvent): + (WebKit::WebViewImpl::applyAutofillSuggestions): + (WebKit::WebViewImpl::applyAutoFillSuggestions): + (WebKit::WebViewImpl::applyAutocompleteSuggestions): + * src/WebViewImpl.h: + +2010-02-09 Chris Guillory <ctguil@google.com> + + Reviewed by Darin Fisher. + + [Chromium] Add function for accessibility object state change notifications. + + https://bugs.webkit.org/show_bug.cgi?id=34464 + + * gyp_webkit: + * public/WebViewClient.h: + (WebKit::WebViewClient::didChangeAccessibilityObjectState): + * src/ChromeClientImpl.cpp: + (WebKit::ChromeClientImpl::didChangeAccessibilityObjectState): + * src/ChromeClientImpl.h: + +2010-02-09 Mikhail Naganov <mnaganov@chromium.org> + + Reviewed by Pavel Feldman. + + Continuing debugger and profiler unforking: narrow scope of JSC-specific ifdefs. + Also, enable JAVASCRIPT_DEBUGGER explicitly in features, it appears to be required + for really enabling it in V8 bindings generation. + + https://bugs.webkit.org/show_bug.cgi?id=34706 + + * features.gypi: + +2010-02-09 Jian Li <jianli@chromium.org> + + Reviewed by Darin Fisher. + + [chromium] Add the chromium interface to support Blob.slice. + https://bugs.webkit.org/show_bug.cgi?id=34652 + + * WebKit.gyp: + * public/WebFileInfo.h: Added. + * public/WebHTTPBody.h: + * src/WebHTTPBody.cpp: + (WebKit::WebHTTPBody::elementAt): + (WebKit::WebHTTPBody::appendFile): + +2010-02-09 Yury Semikhatsky <yurys@chromium.org> + + Unreviewed. Follow-up fix. + + Add missing devTools.css file. + + https://bugs.webkit.org/show_bug.cgi?id=34756 + + * src/js/devTools.css: Added. + +2010-02-09 Yury Semikhatsky <yurys@chromium.org> + + Reviewed by Pavel Feldman. + + Upstream DevTools Images and .css files. + + https://bugs.webkit.org/show_bug.cgi?id=34756 + + * WebKit.gypi: + * src/js/DevTools.css: Added. + * src/js/Images/segmentChromium.png: Added. + * src/js/Images/segmentHoverChromium.png: Added. + * src/js/Images/segmentHoverEndChromium.png: Added. + * src/js/Images/segmentSelectedChromium.png: Added. + * src/js/Images/segmentSelectedEndChromium.png: Added. + * src/js/Images/statusbarBackgroundChromium.png: Added. + * src/js/Images/statusbarBottomBackgroundChromium.png: Added. + * src/js/Images/statusbarButtonsChromium.png: Added. + * src/js/Images/statusbarMenuButtonChromium.png: Added. + * src/js/Images/statusbarMenuButtonSelectedChromium.png: Added. + +2010-02-09 Yury Semikhatsky <yurys@chromium.org> + + Reviewed by Pavel Feldman. + + Upstream JavaScript part of DevTools WebKit API implementation(now + with the added files). + + https://bugs.webkit.org/show_bug.cgi?id=34744 + + * WebKit.gypi: Added. + * src/js/DebuggerAgent.js: Added. + (devtools.DebuggerAgent): + (devtools.DebuggerAgent.prototype.reset): + (devtools.DebuggerAgent.prototype.initUI): + (devtools.DebuggerAgent.prototype.resolveScriptSource.this.requestSeqToCallback_.cmd.getSequenceNumber): + (devtools.DebuggerAgent.prototype.resolveScriptSource): + (devtools.DebuggerAgent.prototype.pauseExecution): + (devtools.DebuggerAgent.prototype.addBreakpoint): + (devtools.DebuggerAgent.prototype.removeBreakpoint): + (devtools.DebuggerAgent.prototype.updateBreakpoint): + (devtools.DebuggerAgent.prototype.stepIntoStatement): + (devtools.DebuggerAgent.prototype.stepOutOfFunction): + (devtools.DebuggerAgent.prototype.stepOverStatement): + (devtools.DebuggerAgent.prototype.resumeExecution): + (devtools.DebuggerAgent.prototype.createExceptionMessage_): + (devtools.DebuggerAgent.prototype.showPendingExceptionMessage_): + (devtools.DebuggerAgent.prototype.clearExceptionMessage_): + (devtools.DebuggerAgent.prototype.pauseOnExceptions): + (devtools.DebuggerAgent.prototype.setPauseOnExceptions): + (devtools.DebuggerAgent.prototype.requestEvaluate): + (devtools.DebuggerAgent.prototype.resolveChildren): + (devtools.DebuggerAgent.prototype.resolveScope.this.requestSeqToCallback_.cmd.getSequenceNumber): + (devtools.DebuggerAgent.prototype.resolveScope): + (devtools.DebuggerAgent.prototype.resolveFrameVariables_.scopeResponseHandler): + (devtools.DebuggerAgent.prototype.resolveFrameVariables_): + (devtools.DebuggerAgent.prototype.resolveCompletionsOnFrame): + (devtools.DebuggerAgent.prototype.getScriptContextType): + (devtools.DebuggerAgent.prototype.requestClearBreakpoint_): + (devtools.DebuggerAgent.prototype.requestChangeBreakpoint_): + (devtools.DebuggerAgent.prototype.requestBacktrace_): + (devtools.DebuggerAgent.sendCommand_): + (devtools.DebuggerAgent.prototype.stepCommand_): + (devtools.DebuggerAgent.prototype.requestLookup_): + (devtools.DebuggerAgent.prototype.setContextId_.this.requestSeqToCallback_.cmd.getSequenceNumber): + (devtools.DebuggerAgent.prototype.setContextId_): + (devtools.DebuggerAgent.prototype.handleDebuggerOutput_): + (devtools.DebuggerAgent.prototype.handleBreakEvent_): + (devtools.DebuggerAgent.prototype.handleExceptionEvent_): + (devtools.DebuggerAgent.prototype.handleScriptsResponse_): + (devtools.DebuggerAgent.prototype.isScriptFromInspectedContext_): + (devtools.DebuggerAgent.prototype.handleSetBreakpointResponse_): + (devtools.DebuggerAgent.prototype.handleAfterCompileEvent_): + (devtools.DebuggerAgent.prototype.addScriptInfo_): + (devtools.DebuggerAgent.prototype.handleClearBreakpointResponse_): + (devtools.DebuggerAgent.prototype.handleBacktraceResponse_): + (devtools.DebuggerAgent.prototype.doHandleBacktraceResponse_): + (devtools.DebuggerAgent.prototype.evaluateInCallFrame): + (devtools.DebuggerAgent.prototype.invokeCallbackForResponse_): + (devtools.DebuggerAgent.prototype.formatCallFrame_): + (devtools.DebuggerAgent.formatObjectProperties_): + (devtools.DebuggerAgent.propertiesToProxies_): + (devtools.DebuggerAgent.formatObjectProxy_): + (devtools.DebuggerAgent.webkitToV8LineNumber_): + (devtools.DebuggerAgent.v8ToWwebkitLineNumber_): + (devtools.ScriptInfo): + (devtools.ScriptInfo.prototype.getLineOffset): + (devtools.ScriptInfo.prototype.getContextType): + (devtools.ScriptInfo.prototype.getUrl): + (devtools.ScriptInfo.prototype.isUnresolved): + (devtools.ScriptInfo.prototype.getBreakpointInfo): + (devtools.ScriptInfo.prototype.addBreakpointInfo): + (devtools.ScriptInfo.prototype.removeBreakpointInfo): + (devtools.BreakpointInfo): + (devtools.BreakpointInfo.prototype.getLine): + (devtools.BreakpointInfo.prototype.getV8Id): + (devtools.BreakpointInfo.prototype.setV8Id): + (devtools.BreakpointInfo.prototype.markAsRemoved): + (devtools.BreakpointInfo.prototype.isRemoved): + (devtools.CallFrame): + (devtools.CallFrame.prototype.evaluate_): + (devtools.DebugCommand): + (devtools.DebugCommand.prototype.getSequenceNumber): + (devtools.DebugCommand.prototype.toJSONProtocol): + (devtools.DebuggerMessage): + (devtools.DebuggerMessage.prototype.getType): + (devtools.DebuggerMessage.prototype.getEvent): + (devtools.DebuggerMessage.prototype.getCommand): + (devtools.DebuggerMessage.prototype.getRequestSeq): + (devtools.DebuggerMessage.prototype.isRunning): + (devtools.DebuggerMessage.prototype.isSuccess): + (devtools.DebuggerMessage.prototype.getMessage): + (devtools.DebuggerMessage.prototype.getBody): + (devtools.DebuggerMessage.prototype.lookup): + * src/js/DevTools.js: Added. + (devtools.dispatch): + (devtools.ToolsAgent): + (devtools.ToolsAgent.prototype.reset): + (devtools.ToolsAgent.prototype.evaluateJavaScript): + (devtools.ToolsAgent.prototype.getDebuggerAgent): + (devtools.ToolsAgent.prototype.getProfilerAgent): + (devtools.ToolsAgent.prototype.frameNavigate_): + (devtools.ToolsAgent.prototype.dispatchOnClient_): + (devtools.ToolsAgent.prototype.evaluate): + (WebInspector.setResourcesPanelEnabled): + (debugPrint): + (devtools): + (WebInspector.loaded): + (): + (WebInspector.ScriptView.prototype.setupSourceFrameIfNeeded): + (WebInspector.ScriptView.prototype.didResolveScriptSource_): + (WebInspector.UnresolvedPropertyValue): + (WebInspector.UIString): + (WebInspector.resourceTrackingWasEnabled): + (WebInspector.resourceTrackingWasDisabled): + (WebInspector.TestController.prototype.runAfterPendingDispatches): + (WebInspector.queuesAreEmpty): + (WebInspector.pausedScript): + * src/js/DevToolsHostStub.js: Added. + (.RemoteDebuggerAgentStub): + (.RemoteDebuggerAgentStub.prototype.getContextId): + (.RemoteProfilerAgentStub): + (.RemoteProfilerAgentStub.prototype.getActiveProfilerModules): + (.RemoteProfilerAgentStub.prototype.getLogLines): + (.RemoteToolsAgentStub): + (.RemoteToolsAgentStub.prototype.dispatchOnInjectedScript): + (.RemoteToolsAgentStub.prototype.dispatchOnInspectorController): + (.RemoteToolsAgentStub.prototype.executeVoidJavaScript): + (.ProfilerStubHelper): + (.ProfilerStubHelper.GetInstance): + (.ProfilerStubHelper.prototype.StopProfiling): + (.ProfilerStubHelper.prototype.StartProfiling): + (.ProfilerStubHelper.prototype.getActiveProfilerModules): + (.ProfilerStubHelper.prototype.getLogLines): + (.RemoteDebuggerCommandExecutorStub): + (.RemoteDebuggerCommandExecutorStub.prototype.DebuggerCommand): + (.RemoteDebuggerCommandExecutorStub.prototype.DebuggerPauseScript): + (.RemoteDebuggerCommandExecutorStub.prototype.sendResponse_): + (.DevToolsHostStub): + (.DevToolsHostStub.prototype.reset): + (.DevToolsHostStub.prototype.setting): + (.DevToolsHostStub.prototype.setSetting): + * src/js/HeapProfilerPanel.js: Added. + (WebInspector.ProfilesPanel.prototype.addSnapshot): + (WebInspector.HeapSnapshotView): + (WebInspector.HeapSnapshotView.prototype.get statusBarItems): + (WebInspector.HeapSnapshotView.prototype.get profile): + (WebInspector.HeapSnapshotView.prototype.set profile): + (WebInspector.HeapSnapshotView.prototype.show): + (WebInspector.HeapSnapshotView.prototype.hide): + (WebInspector.HeapSnapshotView.prototype.resize): + (WebInspector.HeapSnapshotView.prototype.refresh): + (WebInspector.HeapSnapshotView.prototype.refreshShowAsPercents): + (WebInspector.HeapSnapshotView.prototype._deleteSearchMatchedFlags): + (WebInspector.HeapSnapshotView.prototype.searchCanceled): + (WebInspector.HeapSnapshotView.prototype.performSearch): + (WebInspector.HeapSnapshotView.prototype.jumpToFirstSearchResult.WebInspector.CPUProfileView.prototype.jumpToFirstSearchResult.jumpToLastSearchResult.WebInspector.CPUProfileView.prototype.jumpToLastSearchResult.jumpToNextSearchResult.WebInspector.CPUProfileView.prototype.jumpToNextSearchResult.jumpToPreviousSearchResult.WebInspector.CPUProfileView.prototype.jumpToPreviousSearchResult.showingFirstSearchResult.WebInspector.CPUProfileView.prototype.showingFirstSearchResult.showingLastSearchResult.WebInspector.CPUProfileView.prototype.showingLastSearchResult._jumpToSearchResult.WebInspector.CPUProfileView.prototype._jumpToSearchResult.refreshVisibleData): + (WebInspector.HeapSnapshotView.prototype._changeBase): + (WebInspector.HeapSnapshotView.prototype._createSnapshotDataGridList): + (WebInspector.HeapSnapshotView.prototype._mouseDownInDataGrid): + (WebInspector.HeapSnapshotView.prototype.get _isShowingAsPercent): + (WebInspector.HeapSnapshotView.prototype._percentClicked): + (WebInspector.HeapSnapshotView.prototype._resetDataGridList): + (WebInspector.HeapSnapshotView.prototype._sortData): + (WebInspector.HeapSnapshotView.prototype._updateBaseOptions): + (WebInspector.HeapSnapshotView.prototype._updatePercentButton): + (WebInspector.HeapSnapshotView.prototype._updateSummaryGraph): + (WebInspector.HeapSnapshotView.SearchHelper.operations.LESS): + (WebInspector.HeapSnapshotView.SearchHelper.operations.LESS_OR_EQUAL): + (WebInspector.HeapSnapshotView.SearchHelper.operations.EQUAL): + (WebInspector.HeapSnapshotView.SearchHelper.operations.GREATER_OR_EQUAL): + (WebInspector.HeapSnapshotView.SearchHelper.operations.GREATER): + (WebInspector.HeapSnapshotView.SearchHelper.parseOperationAndNumber): + (WebInspector.HeapSummaryCalculator): + (WebInspector.HeapSummaryCalculator.prototype.computeSummaryValues): + (WebInspector.HeapSummaryCalculator.prototype.formatValue): + (WebInspector.HeapSummaryCalculator.prototype.get showAsPercent): + (WebInspector.HeapSummaryCalculator.prototype.set showAsPercent): + (WebInspector.HeapSummaryCountCalculator): + (WebInspector.HeapSummaryCountCalculator.prototype._highFromLow): + (WebInspector.HeapSummaryCountCalculator.prototype._valueToString): + (WebInspector.HeapSummarySizeCalculator): + (WebInspector.HeapSummarySizeCalculator.prototype._highFromLow): + (WebInspector.HeapSnapshotSidebarTreeElement): + (WebInspector.HeapSnapshotSidebarTreeElement.prototype.get mainTitle): + (WebInspector.HeapSnapshotSidebarTreeElement.prototype.set mainTitle): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.get _hasRetainers): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.get _parent): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype._populate.if): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype._populate): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.produceDiff): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.sort): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.signForDelta): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.showDeltaAsPercent): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.getTotalCount): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.getTotalSize): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.get countPercent): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.get sizePercent): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.get countDeltaPercent): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.get sizeDeltaPercent): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.get data): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.createCell): + (WebInspector.HeapSnapshotDataGridNode): + (WebInspector.HeapSnapshotDataGridList): + (WebInspector.HeapSnapshotDataGridList.prototype.appendChild): + (WebInspector.HeapSnapshotDataGridList.prototype.insertChild): + (WebInspector.HeapSnapshotDataGridList.prototype.removeChildren): + (WebInspector.HeapSnapshotDataGridList.prototype.populateChildren): + (WebInspector.HeapSnapshotDataGridList.propertyComparator.comparator): + (WebInspector.HeapSnapshotDataGridList.propertyComparator): + (WebInspector.HeapSnapshotDataGridRetainerNode): + (WebInspector.HeapSnapshotDataGridRetainerNode.prototype.get sizePercent): + (WebInspector.HeapSnapshotDataGridRetainerNode.prototype.get sizeDeltaPercent): + (WebInspector.HeapSnapshotDataGridRetainerNode.prototype._calculateRetainers): + (WebInspector.HeapSnapshotProfileType): + (WebInspector.HeapSnapshotProfileType.prototype.get buttonTooltip): + (WebInspector.HeapSnapshotProfileType.prototype.get buttonStyle): + (WebInspector.HeapSnapshotProfileType.prototype.buttonClicked): + (WebInspector.HeapSnapshotProfileType.prototype.get welcomeMessage): + (WebInspector.HeapSnapshotProfileType.prototype.createSidebarTreeElementForProfile): + (WebInspector.HeapSnapshotProfileType.prototype.createView): + (): + * src/js/InjectDispatch.js: Added. + (InspectorControllerDispatcher.dispatch): + (ApuAgentDispatcher.dispatchToApu): + (dispatch): + (devtools): + * src/js/InspectorControllerImpl.js: Added. + (devtools.InspectorBackendImpl): + (devtools.InspectorBackendImpl.prototype.toggleNodeSearch): + (devtools.InspectorBackendImpl.prototype.debuggerEnabled): + (devtools.InspectorBackendImpl.prototype.profilerEnabled): + (devtools.InspectorBackendImpl.prototype.addBreakpoint): + (devtools.InspectorBackendImpl.prototype.removeBreakpoint): + (devtools.InspectorBackendImpl.prototype.updateBreakpoint): + (devtools.InspectorBackendImpl.prototype.pauseInDebugger): + (devtools.InspectorBackendImpl.prototype.resumeDebugger): + (devtools.InspectorBackendImpl.prototype.stepIntoStatementInDebugger): + (devtools.InspectorBackendImpl.prototype.stepOutOfFunctionInDebugger): + (devtools.InspectorBackendImpl.prototype.stepOverStatementInDebugger): + (devtools.InspectorBackendImpl.prototype.setPauseOnExceptionsState): + (devtools.InspectorBackendImpl.prototype.pauseOnExceptionsState): + (devtools.InspectorBackendImpl.prototype.pauseOnExceptions): + (devtools.InspectorBackendImpl.prototype.setPauseOnExceptions): + (devtools.InspectorBackendImpl.prototype.startProfiling): + (devtools.InspectorBackendImpl.prototype.stopProfiling): + (devtools.InspectorBackendImpl.prototype.getProfileHeaders): + (devtools.InspectorBackendImpl.prototype.addFullProfile): + (devtools.InspectorBackendImpl.prototype.getProfile): + (devtools.InspectorBackendImpl.prototype.takeHeapSnapshot): + (devtools.InspectorBackendImpl.prototype.dispatchOnInjectedScript): + (devtools.InspectorBackendImpl.prototype.installInspectorControllerDelegate_): + (devtools.InspectorBackendImpl.prototype.callInspectorController_): + * src/js/ProfilerAgent.js: Added. + (devtools.ProfilerAgent): + (devtools.ProfilerAgent.prototype.setupProfilerProcessorCallbacks): + (devtools.ProfilerAgent.prototype.initializeProfiling): + (devtools.ProfilerAgent.prototype.startProfiling): + (devtools.ProfilerAgent.prototype.stopProfiling): + (devtools.ProfilerAgent.prototype.didGetActiveProfilerModules_): + (devtools.ProfilerAgent.prototype.didGetLogLines_): + * src/js/ProfilerProcessor.js: Added. + (devtools.profiler.WebKitViewBuilder): + (devtools.profiler.WebKitViewBuilder.prototype.createViewNode): + (devtools.profiler.WebKitViewNode): + (set get devtools.profiler.WebKitViewNode.prototype.initFuncInfo_): + (devtools.profiler.JsProfile): + (devtools.profiler.JsProfile.prototype.skipThisFunction): + (devtools.profiler.Processor): + (devtools.profiler.Processor.prototype.printError): + (devtools.profiler.Processor.prototype.skipDispatch): + (devtools.profiler.Processor.prototype.setCallbacks): + (devtools.profiler.Processor.prototype.setNewProfileCallback): + (devtools.profiler.Processor.prototype.processProfiler_.switch.break): + (devtools.profiler.Processor.prototype.processProfiler_): + (devtools.profiler.Processor.prototype.processCodeCreation_): + (devtools.profiler.Processor.prototype.processCodeMove_): + (devtools.profiler.Processor.prototype.processCodeDelete_): + (devtools.profiler.Processor.prototype.processFunctionCreation_): + (devtools.profiler.Processor.prototype.processFunctionMove_): + (devtools.profiler.Processor.prototype.processFunctionDelete_): + (devtools.profiler.Processor.prototype.processTick_): + (devtools.profiler.Processor.prototype.processTickV2_): + (devtools.profiler.Processor.prototype.processHeapSampleBegin_): + (devtools.profiler.Processor.prototype.processHeapSampleStats_): + (devtools.profiler.Processor.prototype.processHeapSampleItem_): + (devtools.profiler.Processor.prototype.processHeapJsConsItem_): + (devtools.profiler.Processor.prototype.processHeapJsRetItem_.mergeRetainers): + (devtools.profiler.Processor.prototype.processHeapJsRetItem_): + (devtools.profiler.Processor.prototype.processHeapSampleEnd_): + (devtools.profiler.Processor.prototype.createProfileForView): + * src/js/Tests.js: Added. + (.TestSuite): + (.TestSuite.prototype.fail): + (.TestSuite.prototype.assertEquals): + (.TestSuite.prototype.assertTrue): + (.TestSuite.prototype.assertContains): + (.TestSuite.prototype.takeControl): + (.TestSuite.prototype.releaseControl): + (.TestSuite.prototype.reportOk_): + (.TestSuite.prototype.reportFailure_): + (.TestSuite.prototype.runTest): + (.TestSuite.prototype.showPanel): + (.TestSuite.prototype.addSniffer.receiver.methodName): + (.TestSuite.prototype.addSniffer): + (.TestSuite.prototype.testHostIsPresent): + (.TestSuite.prototype.testElementsTreeRoot): + (.TestSuite.prototype.testMainResource): + (.TestSuite.prototype.testResourceContentLength.this.addSniffer.): + (.TestSuite.prototype.testResourceHeaders): + (.TestSuite.prototype.testCachedResourceMimeType.this.addSniffer.): + (.TestSuite.prototype.testCachedResourceMimeType): + (.TestSuite.prototype.testProfilerTab): + (.TestSuite.prototype.testScriptsTabIsPopulatedOnInspectedPageRefresh.waitUntilScriptIsParsed): + (.TestSuite.prototype.testScriptsTabIsPopulatedOnInspectedPageRefresh.checkScriptsPanel): + (.TestSuite.prototype.testScriptsTabIsPopulatedOnInspectedPageRefresh): + (.TestSuite.prototype.testNoScriptDuplicatesOnPanelSwitch.switchToElementsTab): + (.TestSuite.prototype.testNoScriptDuplicatesOnPanelSwitch.switchToScriptsTab): + (.TestSuite.prototype.testNoScriptDuplicatesOnPanelSwitch.checkScriptsPanel): + (.TestSuite.prototype.testNoScriptDuplicatesOnPanelSwitch.checkNoDuplicates): + (.TestSuite.prototype.testPauseOnException): + (.TestSuite.prototype.testPauseWhenLoadingDevTools): + (.TestSuite.prototype.testPauseWhenScriptIsRunning.testScriptPauseAfterDelay): + (.TestSuite.prototype.testPauseWhenScriptIsRunning.testScriptPause): + (.TestSuite.prototype.testPauseWhenScriptIsRunning): + (.TestSuite.prototype.optionsToString_): + (.TestSuite.prototype.evaluateInConsole_): + (.TestSuite.prototype.waitForSetBreakpointResponse_): + (.TestSuite.prototype.testEvalOnCallFrame.setBreakpointCallback): + (.TestSuite.prototype.testEvalOnCallFrame.waitForBreakpointHit): + (.TestSuite.prototype.testCompletionOnPause): + (.TestSuite.prototype.testCompletionOnPause.testLocalsCompletion): + (.TestSuite.prototype.testCompletionOnPause.testThisCompletion): + (.TestSuite.prototype.testCompletionOnPause.testFieldCompletion): + (.TestSuite.prototype.testCompletionOnPause.checkCompletions): + (.TestSuite.prototype.testAutoContinueOnSyntaxError.checkScriptsList): + (.TestSuite.prototype.testAutoContinueOnSyntaxError.waitForExceptionEvent.test): + (.TestSuite.prototype.testAutoContinueOnSyntaxError.waitForExceptionEvent): + (.TestSuite.prototype._checkExecutionLine): + (.TestSuite.prototype._scriptsAreParsed): + (.TestSuite.prototype._waitForScriptPause): + (.TestSuite.prototype._checkSourceFrameWhenLoaded.checkExecLine): + (.TestSuite.prototype._checkSourceFrameWhenLoaded): + (.TestSuite.prototype._performSteps.doNextAction): + (.TestSuite.prototype._performSteps): + (.TestSuite.prototype._executeCodeWhenScriptsAreParsed.executeFunctionInInspectedPage): + (.TestSuite.prototype._waitUntilScriptsAreParsed.waitForAllScripts): + (.TestSuite.prototype._waitUntilScriptsAreParsed): + (.TestSuite.prototype._executeFunctionForStepTest): + (.TestSuite.prototype.testStepOver): + (.TestSuite.prototype.testStepOut): + (.TestSuite.prototype.testStepIn): + (.TestSuite.prototype._evaluateXpath): + (.TestSuite.prototype._findNode): + (.TestSuite.prototype._findText): + (.TestSuite.prototype._nodeIterator): + (.TestSuite.prototype._checkScopeSectionDiv): + (.TestSuite.prototype._expandScopeSections.updateListener): + (.TestSuite.prototype._expandScopeSections): + (.TestSuite.prototype.testExpandScope): + (.TestSuite.prototype.testExpandScope.examineScopes): + (.TestSuite.prototype._findChildProperty): + (.TestSuite.prototype._hookGetPropertiesCallback.accessor.getProperties): + (.TestSuite.prototype._hookGetPropertiesCallback.try): + (.TestSuite.prototype._hookGetPropertiesCallback): + (.TestSuite.prototype.testDebugIntrinsicProperties.expandLocalScope): + (.TestSuite.prototype.testDebugIntrinsicProperties): + (.TestSuite.prototype.testDebugIntrinsicProperties.expandAndCheckNextProperty): + (.TestSuite.prototype.testDebugIntrinsicProperties.checkProperty): + (.TestSuite.createKeyEvent): + (.TestSuite.prototype.testConsoleLog.assertNext): + (.TestSuite.prototype.testConsoleLog): + (.TestSuite.prototype.testEvalGlobal.initEval): + (.TestSuite.prototype.testEvalGlobal): + (.TestSuite.prototype.testShowStoragePanel.this.addSniffer.): + (.TestSuite.prototype.testShowStoragePanel.this.addSniffer): + (.uiTests.runAllTests): + (.uiTests.runTest): + +2010-02-09 Yury Semikhatsky <yurys@chromium.org> + + Reviewed by Pavel Feldman. + + Upstream JavaScript part of DevTools WebKit API implementation + + https://bugs.webkit.org/show_bug.cgi?id=34744 + + * WebKit.gypi: Added. + * src/js/DebuggerAgent.js: Added. + (devtools.DebuggerAgent): + (devtools.DebuggerAgent.prototype.reset): + (devtools.DebuggerAgent.prototype.initUI): + (devtools.DebuggerAgent.prototype.resolveScriptSource.this.requestSeqToCallback_.cmd.getSequenceNumber): + (devtools.DebuggerAgent.prototype.resolveScriptSource): + (devtools.DebuggerAgent.prototype.pauseExecution): + (devtools.DebuggerAgent.prototype.addBreakpoint): + (devtools.DebuggerAgent.prototype.removeBreakpoint): + (devtools.DebuggerAgent.prototype.updateBreakpoint): + (devtools.DebuggerAgent.prototype.stepIntoStatement): + (devtools.DebuggerAgent.prototype.stepOutOfFunction): + (devtools.DebuggerAgent.prototype.stepOverStatement): + (devtools.DebuggerAgent.prototype.resumeExecution): + (devtools.DebuggerAgent.prototype.createExceptionMessage_): + (devtools.DebuggerAgent.prototype.showPendingExceptionMessage_): + (devtools.DebuggerAgent.prototype.clearExceptionMessage_): + (devtools.DebuggerAgent.prototype.pauseOnExceptions): + (devtools.DebuggerAgent.prototype.setPauseOnExceptions): + (devtools.DebuggerAgent.prototype.requestEvaluate): + (devtools.DebuggerAgent.prototype.resolveChildren): + (devtools.DebuggerAgent.prototype.resolveScope.this.requestSeqToCallback_.cmd.getSequenceNumber): + (devtools.DebuggerAgent.prototype.resolveScope): + (devtools.DebuggerAgent.prototype.resolveFrameVariables_.scopeResponseHandler): + (devtools.DebuggerAgent.prototype.resolveFrameVariables_): + (devtools.DebuggerAgent.prototype.resolveCompletionsOnFrame): + (devtools.DebuggerAgent.prototype.getScriptContextType): + (devtools.DebuggerAgent.prototype.requestClearBreakpoint_): + (devtools.DebuggerAgent.prototype.requestChangeBreakpoint_): + (devtools.DebuggerAgent.prototype.requestBacktrace_): + (devtools.DebuggerAgent.sendCommand_): + (devtools.DebuggerAgent.prototype.stepCommand_): + (devtools.DebuggerAgent.prototype.requestLookup_): + (devtools.DebuggerAgent.prototype.setContextId_.this.requestSeqToCallback_.cmd.getSequenceNumber): + (devtools.DebuggerAgent.prototype.setContextId_): + (devtools.DebuggerAgent.prototype.handleDebuggerOutput_): + (devtools.DebuggerAgent.prototype.handleBreakEvent_): + (devtools.DebuggerAgent.prototype.handleExceptionEvent_): + (devtools.DebuggerAgent.prototype.handleScriptsResponse_): + (devtools.DebuggerAgent.prototype.isScriptFromInspectedContext_): + (devtools.DebuggerAgent.prototype.handleSetBreakpointResponse_): + (devtools.DebuggerAgent.prototype.handleAfterCompileEvent_): + (devtools.DebuggerAgent.prototype.addScriptInfo_): + (devtools.DebuggerAgent.prototype.handleClearBreakpointResponse_): + (devtools.DebuggerAgent.prototype.handleBacktraceResponse_): + (devtools.DebuggerAgent.prototype.doHandleBacktraceResponse_): + (devtools.DebuggerAgent.prototype.evaluateInCallFrame): + (devtools.DebuggerAgent.prototype.invokeCallbackForResponse_): + (devtools.DebuggerAgent.prototype.formatCallFrame_): + (devtools.DebuggerAgent.formatObjectProperties_): + (devtools.DebuggerAgent.propertiesToProxies_): + (devtools.DebuggerAgent.formatObjectProxy_): + (devtools.DebuggerAgent.webkitToV8LineNumber_): + (devtools.DebuggerAgent.v8ToWwebkitLineNumber_): + (devtools.ScriptInfo): + (devtools.ScriptInfo.prototype.getLineOffset): + (devtools.ScriptInfo.prototype.getContextType): + (devtools.ScriptInfo.prototype.getUrl): + (devtools.ScriptInfo.prototype.isUnresolved): + (devtools.ScriptInfo.prototype.getBreakpointInfo): + (devtools.ScriptInfo.prototype.addBreakpointInfo): + (devtools.ScriptInfo.prototype.removeBreakpointInfo): + (devtools.BreakpointInfo): + (devtools.BreakpointInfo.prototype.getLine): + (devtools.BreakpointInfo.prototype.getV8Id): + (devtools.BreakpointInfo.prototype.setV8Id): + (devtools.BreakpointInfo.prototype.markAsRemoved): + (devtools.BreakpointInfo.prototype.isRemoved): + (devtools.CallFrame): + (devtools.CallFrame.prototype.evaluate_): + (devtools.DebugCommand): + (devtools.DebugCommand.prototype.getSequenceNumber): + (devtools.DebugCommand.prototype.toJSONProtocol): + (devtools.DebuggerMessage): + (devtools.DebuggerMessage.prototype.getType): + (devtools.DebuggerMessage.prototype.getEvent): + (devtools.DebuggerMessage.prototype.getCommand): + (devtools.DebuggerMessage.prototype.getRequestSeq): + (devtools.DebuggerMessage.prototype.isRunning): + (devtools.DebuggerMessage.prototype.isSuccess): + (devtools.DebuggerMessage.prototype.getMessage): + (devtools.DebuggerMessage.prototype.getBody): + (devtools.DebuggerMessage.prototype.lookup): + * src/js/DevTools.js: Added. + (devtools.dispatch): + (devtools.ToolsAgent): + (devtools.ToolsAgent.prototype.reset): + (devtools.ToolsAgent.prototype.evaluateJavaScript): + (devtools.ToolsAgent.prototype.getDebuggerAgent): + (devtools.ToolsAgent.prototype.getProfilerAgent): + (devtools.ToolsAgent.prototype.frameNavigate_): + (devtools.ToolsAgent.prototype.dispatchOnClient_): + (devtools.ToolsAgent.prototype.evaluate): + (WebInspector.setResourcesPanelEnabled): + (debugPrint): + (devtools): + (WebInspector.loaded): + (): + (WebInspector.ScriptView.prototype.setupSourceFrameIfNeeded): + (WebInspector.ScriptView.prototype.didResolveScriptSource_): + (WebInspector.UnresolvedPropertyValue): + (WebInspector.UIString): + (WebInspector.resourceTrackingWasEnabled): + (WebInspector.resourceTrackingWasDisabled): + (WebInspector.TestController.prototype.runAfterPendingDispatches): + (WebInspector.queuesAreEmpty): + (WebInspector.pausedScript): + * src/js/DevToolsHostStub.js: Added. + (.RemoteDebuggerAgentStub): + (.RemoteDebuggerAgentStub.prototype.getContextId): + (.RemoteProfilerAgentStub): + (.RemoteProfilerAgentStub.prototype.getActiveProfilerModules): + (.RemoteProfilerAgentStub.prototype.getLogLines): + (.RemoteToolsAgentStub): + (.RemoteToolsAgentStub.prototype.dispatchOnInjectedScript): + (.RemoteToolsAgentStub.prototype.dispatchOnInspectorController): + (.RemoteToolsAgentStub.prototype.executeVoidJavaScript): + (.ProfilerStubHelper): + (.ProfilerStubHelper.GetInstance): + (.ProfilerStubHelper.prototype.StopProfiling): + (.ProfilerStubHelper.prototype.StartProfiling): + (.ProfilerStubHelper.prototype.getActiveProfilerModules): + (.ProfilerStubHelper.prototype.getLogLines): + (.RemoteDebuggerCommandExecutorStub): + (.RemoteDebuggerCommandExecutorStub.prototype.DebuggerCommand): + (.RemoteDebuggerCommandExecutorStub.prototype.DebuggerPauseScript): + (.RemoteDebuggerCommandExecutorStub.prototype.sendResponse_): + (.DevToolsHostStub): + (.DevToolsHostStub.prototype.reset): + (.DevToolsHostStub.prototype.setting): + (.DevToolsHostStub.prototype.setSetting): + * src/js/HeapProfilerPanel.js: Added. + (WebInspector.ProfilesPanel.prototype.addSnapshot): + (WebInspector.HeapSnapshotView): + (WebInspector.HeapSnapshotView.prototype.get statusBarItems): + (WebInspector.HeapSnapshotView.prototype.get profile): + (WebInspector.HeapSnapshotView.prototype.set profile): + (WebInspector.HeapSnapshotView.prototype.show): + (WebInspector.HeapSnapshotView.prototype.hide): + (WebInspector.HeapSnapshotView.prototype.resize): + (WebInspector.HeapSnapshotView.prototype.refresh): + (WebInspector.HeapSnapshotView.prototype.refreshShowAsPercents): + (WebInspector.HeapSnapshotView.prototype._deleteSearchMatchedFlags): + (WebInspector.HeapSnapshotView.prototype.searchCanceled): + (WebInspector.HeapSnapshotView.prototype.performSearch): + (WebInspector.HeapSnapshotView.prototype.jumpToFirstSearchResult.WebInspector.CPUProfileView.prototype.jumpToFirstSearchResult.jumpToLastSearchResult.WebInspector.CPUProfileView.prototype.jumpToLastSearchResult.jumpToNextSearchResult.WebInspector.CPUProfileView.prototype.jumpToNextSearchResult.jumpToPreviousSearchResult.WebInspector.CPUProfileView.prototype.jumpToPreviousSearchResult.showingFirstSearchResult.WebInspector.CPUProfileView.prototype.showingFirstSearchResult.showingLastSearchResult.WebInspector.CPUProfileView.prototype.showingLastSearchResult._jumpToSearchResult.WebInspector.CPUProfileView.prototype._jumpToSearchResult.refreshVisibleData): + (WebInspector.HeapSnapshotView.prototype._changeBase): + (WebInspector.HeapSnapshotView.prototype._createSnapshotDataGridList): + (WebInspector.HeapSnapshotView.prototype._mouseDownInDataGrid): + (WebInspector.HeapSnapshotView.prototype.get _isShowingAsPercent): + (WebInspector.HeapSnapshotView.prototype._percentClicked): + (WebInspector.HeapSnapshotView.prototype._resetDataGridList): + (WebInspector.HeapSnapshotView.prototype._sortData): + (WebInspector.HeapSnapshotView.prototype._updateBaseOptions): + (WebInspector.HeapSnapshotView.prototype._updatePercentButton): + (WebInspector.HeapSnapshotView.prototype._updateSummaryGraph): + (WebInspector.HeapSnapshotView.SearchHelper.operations.LESS): + (WebInspector.HeapSnapshotView.SearchHelper.operations.LESS_OR_EQUAL): + (WebInspector.HeapSnapshotView.SearchHelper.operations.EQUAL): + (WebInspector.HeapSnapshotView.SearchHelper.operations.GREATER_OR_EQUAL): + (WebInspector.HeapSnapshotView.SearchHelper.operations.GREATER): + (WebInspector.HeapSnapshotView.SearchHelper.parseOperationAndNumber): + (WebInspector.HeapSummaryCalculator): + (WebInspector.HeapSummaryCalculator.prototype.computeSummaryValues): + (WebInspector.HeapSummaryCalculator.prototype.formatValue): + (WebInspector.HeapSummaryCalculator.prototype.get showAsPercent): + (WebInspector.HeapSummaryCalculator.prototype.set showAsPercent): + (WebInspector.HeapSummaryCountCalculator): + (WebInspector.HeapSummaryCountCalculator.prototype._highFromLow): + (WebInspector.HeapSummaryCountCalculator.prototype._valueToString): + (WebInspector.HeapSummarySizeCalculator): + (WebInspector.HeapSummarySizeCalculator.prototype._highFromLow): + (WebInspector.HeapSnapshotSidebarTreeElement): + (WebInspector.HeapSnapshotSidebarTreeElement.prototype.get mainTitle): + (WebInspector.HeapSnapshotSidebarTreeElement.prototype.set mainTitle): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.get _hasRetainers): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.get _parent): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype._populate.if): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype._populate): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.produceDiff): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.sort): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.signForDelta): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.showDeltaAsPercent): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.getTotalCount): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.getTotalSize): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.get countPercent): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.get sizePercent): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.get countDeltaPercent): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.get sizeDeltaPercent): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.get data): + (WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.createCell): + (WebInspector.HeapSnapshotDataGridNode): + (WebInspector.HeapSnapshotDataGridList): + (WebInspector.HeapSnapshotDataGridList.prototype.appendChild): + (WebInspector.HeapSnapshotDataGridList.prototype.insertChild): + (WebInspector.HeapSnapshotDataGridList.prototype.removeChildren): + (WebInspector.HeapSnapshotDataGridList.prototype.populateChildren): + (WebInspector.HeapSnapshotDataGridList.propertyComparator.comparator): + (WebInspector.HeapSnapshotDataGridList.propertyComparator): + (WebInspector.HeapSnapshotDataGridRetainerNode): + (WebInspector.HeapSnapshotDataGridRetainerNode.prototype.get sizePercent): + (WebInspector.HeapSnapshotDataGridRetainerNode.prototype.get sizeDeltaPercent): + (WebInspector.HeapSnapshotDataGridRetainerNode.prototype._calculateRetainers): + (WebInspector.HeapSnapshotProfileType): + (WebInspector.HeapSnapshotProfileType.prototype.get buttonTooltip): + (WebInspector.HeapSnapshotProfileType.prototype.get buttonStyle): + (WebInspector.HeapSnapshotProfileType.prototype.buttonClicked): + (WebInspector.HeapSnapshotProfileType.prototype.get welcomeMessage): + (WebInspector.HeapSnapshotProfileType.prototype.createSidebarTreeElementForProfile): + (WebInspector.HeapSnapshotProfileType.prototype.createView): + (): + * src/js/InjectDispatch.js: Added. + (InspectorControllerDispatcher.dispatch): + (ApuAgentDispatcher.dispatchToApu): + (dispatch): + (devtools): + * src/js/InspectorControllerImpl.js: Added. + (devtools.InspectorBackendImpl): + (devtools.InspectorBackendImpl.prototype.toggleNodeSearch): + (devtools.InspectorBackendImpl.prototype.debuggerEnabled): + (devtools.InspectorBackendImpl.prototype.profilerEnabled): + (devtools.InspectorBackendImpl.prototype.addBreakpoint): + (devtools.InspectorBackendImpl.prototype.removeBreakpoint): + (devtools.InspectorBackendImpl.prototype.updateBreakpoint): + (devtools.InspectorBackendImpl.prototype.pauseInDebugger): + (devtools.InspectorBackendImpl.prototype.resumeDebugger): + (devtools.InspectorBackendImpl.prototype.stepIntoStatementInDebugger): + (devtools.InspectorBackendImpl.prototype.stepOutOfFunctionInDebugger): + (devtools.InspectorBackendImpl.prototype.stepOverStatementInDebugger): + (devtools.InspectorBackendImpl.prototype.setPauseOnExceptionsState): + (devtools.InspectorBackendImpl.prototype.pauseOnExceptionsState): + (devtools.InspectorBackendImpl.prototype.pauseOnExceptions): + (devtools.InspectorBackendImpl.prototype.setPauseOnExceptions): + (devtools.InspectorBackendImpl.prototype.startProfiling): + (devtools.InspectorBackendImpl.prototype.stopProfiling): + (devtools.InspectorBackendImpl.prototype.getProfileHeaders): + (devtools.InspectorBackendImpl.prototype.addFullProfile): + (devtools.InspectorBackendImpl.prototype.getProfile): + (devtools.InspectorBackendImpl.prototype.takeHeapSnapshot): + (devtools.InspectorBackendImpl.prototype.dispatchOnInjectedScript): + (devtools.InspectorBackendImpl.prototype.installInspectorControllerDelegate_): + (devtools.InspectorBackendImpl.prototype.callInspectorController_): + * src/js/ProfilerAgent.js: Added. + (devtools.ProfilerAgent): + (devtools.ProfilerAgent.prototype.setupProfilerProcessorCallbacks): + (devtools.ProfilerAgent.prototype.initializeProfiling): + (devtools.ProfilerAgent.prototype.startProfiling): + (devtools.ProfilerAgent.prototype.stopProfiling): + (devtools.ProfilerAgent.prototype.didGetActiveProfilerModules_): + (devtools.ProfilerAgent.prototype.didGetLogLines_): + * src/js/ProfilerProcessor.js: Added. + (devtools.profiler.WebKitViewBuilder): + (devtools.profiler.WebKitViewBuilder.prototype.createViewNode): + (devtools.profiler.WebKitViewNode): + (set get devtools.profiler.WebKitViewNode.prototype.initFuncInfo_): + (devtools.profiler.JsProfile): + (devtools.profiler.JsProfile.prototype.skipThisFunction): + (devtools.profiler.Processor): + (devtools.profiler.Processor.prototype.printError): + (devtools.profiler.Processor.prototype.skipDispatch): + (devtools.profiler.Processor.prototype.setCallbacks): + (devtools.profiler.Processor.prototype.setNewProfileCallback): + (devtools.profiler.Processor.prototype.processProfiler_.switch.break): + (devtools.profiler.Processor.prototype.processProfiler_): + (devtools.profiler.Processor.prototype.processCodeCreation_): + (devtools.profiler.Processor.prototype.processCodeMove_): + (devtools.profiler.Processor.prototype.processCodeDelete_): + (devtools.profiler.Processor.prototype.processFunctionCreation_): + (devtools.profiler.Processor.prototype.processFunctionMove_): + (devtools.profiler.Processor.prototype.processFunctionDelete_): + (devtools.profiler.Processor.prototype.processTick_): + (devtools.profiler.Processor.prototype.processTickV2_): + (devtools.profiler.Processor.prototype.processHeapSampleBegin_): + (devtools.profiler.Processor.prototype.processHeapSampleStats_): + (devtools.profiler.Processor.prototype.processHeapSampleItem_): + (devtools.profiler.Processor.prototype.processHeapJsConsItem_): + (devtools.profiler.Processor.prototype.processHeapJsRetItem_.mergeRetainers): + (devtools.profiler.Processor.prototype.processHeapJsRetItem_): + (devtools.profiler.Processor.prototype.processHeapSampleEnd_): + (devtools.profiler.Processor.prototype.createProfileForView): + * src/js/Tests.js: Added. + (.TestSuite): + (.TestSuite.prototype.fail): + (.TestSuite.prototype.assertEquals): + (.TestSuite.prototype.assertTrue): + (.TestSuite.prototype.assertContains): + (.TestSuite.prototype.takeControl): + (.TestSuite.prototype.releaseControl): + (.TestSuite.prototype.reportOk_): + (.TestSuite.prototype.reportFailure_): + (.TestSuite.prototype.runTest): + (.TestSuite.prototype.showPanel): + (.TestSuite.prototype.addSniffer.receiver.methodName): + (.TestSuite.prototype.addSniffer): + (.TestSuite.prototype.testHostIsPresent): + (.TestSuite.prototype.testElementsTreeRoot): + (.TestSuite.prototype.testMainResource): + (.TestSuite.prototype.testResourceContentLength.this.addSniffer.): + (.TestSuite.prototype.testResourceHeaders): + (.TestSuite.prototype.testCachedResourceMimeType.this.addSniffer.): + (.TestSuite.prototype.testCachedResourceMimeType): + (.TestSuite.prototype.testProfilerTab): + (.TestSuite.prototype.testScriptsTabIsPopulatedOnInspectedPageRefresh.waitUntilScriptIsParsed): + (.TestSuite.prototype.testScriptsTabIsPopulatedOnInspectedPageRefresh.checkScriptsPanel): + (.TestSuite.prototype.testScriptsTabIsPopulatedOnInspectedPageRefresh): + (.TestSuite.prototype.testNoScriptDuplicatesOnPanelSwitch.switchToElementsTab): + (.TestSuite.prototype.testNoScriptDuplicatesOnPanelSwitch.switchToScriptsTab): + (.TestSuite.prototype.testNoScriptDuplicatesOnPanelSwitch.checkScriptsPanel): + (.TestSuite.prototype.testNoScriptDuplicatesOnPanelSwitch.checkNoDuplicates): + (.TestSuite.prototype.testPauseOnException): + (.TestSuite.prototype.testPauseWhenLoadingDevTools): + (.TestSuite.prototype.testPauseWhenScriptIsRunning.testScriptPauseAfterDelay): + (.TestSuite.prototype.testPauseWhenScriptIsRunning.testScriptPause): + (.TestSuite.prototype.testPauseWhenScriptIsRunning): + (.TestSuite.prototype.optionsToString_): + (.TestSuite.prototype.evaluateInConsole_): + (.TestSuite.prototype.waitForSetBreakpointResponse_): + (.TestSuite.prototype.testEvalOnCallFrame.setBreakpointCallback): + (.TestSuite.prototype.testEvalOnCallFrame.waitForBreakpointHit): + (.TestSuite.prototype.testCompletionOnPause): + (.TestSuite.prototype.testCompletionOnPause.testLocalsCompletion): + (.TestSuite.prototype.testCompletionOnPause.testThisCompletion): + (.TestSuite.prototype.testCompletionOnPause.testFieldCompletion): + (.TestSuite.prototype.testCompletionOnPause.checkCompletions): + (.TestSuite.prototype.testAutoContinueOnSyntaxError.checkScriptsList): + (.TestSuite.prototype.testAutoContinueOnSyntaxError.waitForExceptionEvent.test): + (.TestSuite.prototype.testAutoContinueOnSyntaxError.waitForExceptionEvent): + (.TestSuite.prototype._checkExecutionLine): + (.TestSuite.prototype._scriptsAreParsed): + (.TestSuite.prototype._waitForScriptPause): + (.TestSuite.prototype._checkSourceFrameWhenLoaded.checkExecLine): + (.TestSuite.prototype._checkSourceFrameWhenLoaded): + (.TestSuite.prototype._performSteps.doNextAction): + (.TestSuite.prototype._performSteps): + (.TestSuite.prototype._executeCodeWhenScriptsAreParsed.executeFunctionInInspectedPage): + (.TestSuite.prototype._waitUntilScriptsAreParsed.waitForAllScripts): + (.TestSuite.prototype._waitUntilScriptsAreParsed): + (.TestSuite.prototype._executeFunctionForStepTest): + (.TestSuite.prototype.testStepOver): + (.TestSuite.prototype.testStepOut): + (.TestSuite.prototype.testStepIn): + (.TestSuite.prototype._evaluateXpath): + (.TestSuite.prototype._findNode): + (.TestSuite.prototype._findText): + (.TestSuite.prototype._nodeIterator): + (.TestSuite.prototype._checkScopeSectionDiv): + (.TestSuite.prototype._expandScopeSections.updateListener): + (.TestSuite.prototype._expandScopeSections): + (.TestSuite.prototype.testExpandScope): + (.TestSuite.prototype.testExpandScope.examineScopes): + (.TestSuite.prototype._findChildProperty): + (.TestSuite.prototype._hookGetPropertiesCallback.accessor.getProperties): + (.TestSuite.prototype._hookGetPropertiesCallback.try): + (.TestSuite.prototype._hookGetPropertiesCallback): + (.TestSuite.prototype.testDebugIntrinsicProperties.expandLocalScope): + (.TestSuite.prototype.testDebugIntrinsicProperties): + (.TestSuite.prototype.testDebugIntrinsicProperties.expandAndCheckNextProperty): + (.TestSuite.prototype.testDebugIntrinsicProperties.checkProperty): + (.TestSuite.createKeyEvent): + (.TestSuite.prototype.testConsoleLog.assertNext): + (.TestSuite.prototype.testConsoleLog): + (.TestSuite.prototype.testEvalGlobal.initEval): + (.TestSuite.prototype.testEvalGlobal): + (.TestSuite.prototype.testShowStoragePanel.this.addSniffer.): + (.TestSuite.prototype.testShowStoragePanel.this.addSniffer): + (.uiTests.runAllTests): + (.uiTests.runTest): + +2010-02-09 Avi Drissman <avi@chromium.org> + + Reviewed by David Levin. + + Chromium Mac: Control-A shouldn't select all/Control-C shouldn't copy + https://bugs.webkit.org/show_bug.cgi?id=34615 + + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::keyEventDefault): + +2010-02-08 Evan Martin <evan@chromium.org> + + dlopen() knows how to search the library search path, so just rely on + it. While I'm at it, print out the dlerror() error message on failure. + + [chromium] webgl shouldn't hard code library search path + https://bugs.webkit.org/show_bug.cgi?id=34659 + + * src/GraphicsContext3D.cpp: + (WebCore::GraphicsContext3DInternal::GLConnection::GLConnection): + (WebCore::GraphicsContext3DInternal::GLConnection::create): + +2010-02-08 Charlie Reis <creis@chromium.org> + + Reviewed by Darin Adler. + + onbeforeunload not called at window close + frame or iframe focused + https://bugs.webkit.org/show_bug.cgi?id=27481 + http://code.google.com/p/chromium/issues/detail?id=32615 + http://code.google.com/p/chromium/issues/detail?id=17157 + + Chromium and WebKit on Windows will now fire beforeunload handlers + even if an inner frame is focused. + + Layout tests aren't able to test this bug, since it requires closing + the actual browser window, not calling window.close(). Instead, + test with WebCore/manual-tests/onbeforeunload-focused-iframe.html. + + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::dispatchBeforeUnloadEvent): + +2010-02-08 Pavel Feldman <pfeldman@chromium.org> + + Reviewed by David Levin. + + WebKit/chromium: Custom context menu does not work in inspector. + https://bugs.webkit.org/show_bug.cgi?id=34711 + + * src/WebDevToolsFrontendImpl.cpp: + (WebKit::WebDevToolsFrontendImpl::jsShowContextMenu): + +2010-02-08 Nate Chapin <japhet@chromium.org> + + Reviewed by Darin Fisher. + + Check that the index passed into BackForwardListClientImpl::itemAtIndex() + is valid, and return null if it isn't. + + https://bugs.webkit.org/show_bug.cgi?id=34722 + + * src/BackForwardListClientImpl.cpp: + (WebKit::BackForwardListClientImpl::itemAtIndex): + +2010-02-05 Dumitru Daniliuc <dumi@chromium.org> + + Reviewed by Jeremy Orlow. + + Adding a way to close all database handles pointing to a certain + database as soon as possible. + https://bugs.webkit.org/show_bug.cgi?id=34619 + + * public/WebDatabase.h: + * src/WebDatabase.cpp: + (WebKit::WebDatabase::closeDatabaseImmediately): + +2010-02-08 Dirk Schulze <krit@webkit.org> + + Reviewed by Nikolas Zimmermann. + + Add back an AffineTransform class for use by SVG + https://bugs.webkit.org/show_bug.cgi?id=33750 + + Use AffineTransform instead of TransformationMatrix here. + + * tests/TransparencyWinTest.cpp: + (WebCore::TEST): + +2010-02-07 Jian Li <jianli@chromium.org> + + Reviewed by Darin Fisher. + + [chromium] Change chromium interface to handle DownloadURL format. + https://bugs.webkit.org/show_bug.cgi?id=34655 + + * public/WebDragData.h: + * src/WebDragData.cpp: + (WebKit::WebDragData::downloadMetadata): + (WebKit::WebDragData::setDownloadMetadata): + +2010-02-06 Dimitri Glazkov <dglazkov@chromium.org> + + No review, rolling out r54364. + http://trac.webkit.org/changeset/54364 + https://bugs.webkit.org/show_bug.cgi?id=34464 + + Introduced asserts in layout tests, needs more testing + locally. + + * public/WebViewClient.h: + * src/ChromeClientImpl.cpp: + * src/ChromeClientImpl.h: + +2010-02-05 James Hawkins <jhawkins@chromium.org> + + Reviewed by David Levin. + + [Chromium] Rename autocomplete* to suggestions* to prepare for the + refactoring of AutocompletePopupMenuClient. + + https://bugs.webkit.org/show_bug.cgi?id=34664 + + * public/WebView.h: + * src/AutocompletePopupMenuClient.cpp: + (WebKit::AutocompletePopupMenuClient::popupDidHide): + * src/EditorClientImpl.cpp: + (WebKit::EditorClientImpl::textFieldDidEndEditing): + (WebKit::EditorClientImpl::doAutofill): + * src/WebViewImpl.cpp: + (WebKit::): + (WebKit::WebViewImpl::WebViewImpl): + (WebKit::WebViewImpl::mouseDown): + (WebKit::WebViewImpl::autocompleteHandleKeyEvent): + (WebKit::WebViewImpl::setFocus): + (WebKit::WebViewImpl::applyAutofillSuggestions): + (WebKit::WebViewImpl::hideAutofillPopup): + (WebKit::WebViewImpl::hideSuggestionsPopup): + (WebKit::WebViewImpl::refreshSuggestionsPopup): + * src/WebViewImpl.h: + (WebKit::WebViewImpl::suggestionsPopupDidHide): + +2010-02-05 James Hawkins <jhawkins@chromium.org> + + Reviewed by David Levin. + + [Chromium] Remove an unused forward declaration in WebKitClient.h. + + https://bugs.webkit.org/show_bug.cgi?id=34622 + + * public/WebKitClient.h: + +2010-02-05 James Hawkins <jhawkins@chromium.org> + + Reviewed by Darin Fisher. + + Implement WebInputElement::isActivatedSubmit(). + + https://bugs.webkit.org/show_bug.cgi?id=34623 + + * public/WebInputElement.h: + * src/WebInputElement.cpp: + (WebKit::WebInputElement::isActivatedSubmit): + +2010-02-05 Nate Chapin <japhet@chromium.org> + + Reviewed by Dimitri Glazkov. + + Update code for getting a v8::FunctionTemplate. + + https://bugs.webkit.org/show_bug.cgi?id=34606 + + * src/WebDevToolsAgentImpl.cpp: + (WebKit::WebDevToolsAgentImpl::createInspectorBackendV8Wrapper): + +2010-02-05 Mikhail Naganov <mnaganov@chromium.org> + + Reviewed by Pavel Feldman. + + Enable JAVASCRIPT_DEBUGGER in chromium port. + + https://bugs.webkit.org/show_bug.cgi?id=34638 + + * features.gypi: + +2010-02-04 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Darin Fisher. + + Upstreaming gtests from chromium: UniscribeHelper and TransparencyWin + https://bugs.webkit.org/show_bug.cgi?id=34509 + + Resubmit: The previous commit (r54333) was rolled back. + + * WebKit.gyp: + * tests/TransparencyWinTest.cpp: Added. + (WebCore::RECTToFloatRect): + (WebCore::drawNativeRect): + (WebCore::getPixelAt): + (WebCore::clearTopLayerAlphaChannel): + (WebCore::clearTopLayerAlphaPixel): + (WebCore::operator<<): + (WebCore::TEST): + * tests/UniscribeHelperTest.cpp: Added. + (WebCore::UniscribeTest::UniscribeTest): + (WebCore::UniscribeTest::MakeFont): + (WebCore::UniscribeTest::SetUp): + (WebCore::UniscribeTest::TearDown): + (TEST_F): + +2010-02-04 Drew Wilson <atwilson@chromium.org> + + Reviewed by David Levin. + + WorkerContext.close() does not work in the chromium port + https://bugs.webkit.org/show_bug.cgi?id=34551 + + Test: Adding new downstream test. + + * src/WebWorkerBase.cpp: + (WebKit::WebWorkerBase::workerContextClosedTask): + Now shuts down the worker thread when WorkerContext::close() is invoked. + +2010-02-04 Chris Guillory <chris.guillory@google.com> + + Reviewed by Darin Fisher. + + [Chromium] Add function for AccessibilityObject state change notifications. + + https://bugs.webkit.org/show_bug.cgi?id=34464 + + * public/WebViewClient.h: + (WebKit::WebViewClient::didChangeAccessibilityObjectState): + * src/ChromeClientImpl.cpp: + (WebKit::ChromeClientImpl::didChangeAccessibilityObjectState): + * src/ChromeClientImpl.h: + +2010-02-04 Jeremy Moskovich <jeremy@chromium.org> + + Reviewed by Darin Fisher. + + Update comments to better document the possible values of the + writing direction menu state variables. + + * public/WebContextMenuData.h: + +2010-02-04 Nate Chapin <japhet@chromium.org> + + Reviewed by Dimitri Glazkov. + + Remove references to V8Custom. + + https://bugs.webkit.org/show_bug.cgi?id=32638 + + * src/DebuggerAgentImpl.cpp: + * src/WebDevToolsFrontendImpl.cpp: + +2010-02-04 Yury Semikhatsky <yurys@chromium.org> + + Unreviewed. Revert 54333 which broke Chromium build. + + * WebKit.gyp: + * tests/TransparencyWinTest.cpp: Removed. + * tests/UniscribeHelperTest.cpp: Removed. + +2010-02-04 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Darin Fisher. + + Upstreaming gtests from chromium: UniscribeHelper and TransparencyWin. + https://bugs.webkit.org/show_bug.cgi?id=34509 + + * WebKit.gyp: + * tests/TransparencyWinTest.cpp: Added. + (WebCore::RECTToFloatRect): + (WebCore::drawNativeRect): + (WebCore::getPixelAt): + (WebCore::clearTopLayerAlphaChannel): + (WebCore::clearTopLayerAlphaPixel): + (WebCore::operator<<): + (WebCore::TEST): + * tests/UniscribeHelperTest.cpp: Added. + (WebCore::UniscribeTest::UniscribeTest): + (WebCore::UniscribeTest::MakeFont): + (WebCore::UniscribeTest::SetUp): + (WebCore::UniscribeTest::TearDown): + (WebCore::TEST_F): + +2010-02-04 Jeremy Moskovich <jeremy@chromium.org> + + Reviewed by David Levin. + + [Chromium] WebKit side of "Writing direction" context menu on OS X. + https://bugs.webkit.org/show_bug.cgi?id=34524 + + * public/WebContextMenuData.h: + (WebKit::WebContextMenuData::): + * src/ContextMenuClientImpl.cpp: + (WebKit::ContextMenuClientImpl::getCustomMenuFromDefaultItems): + +2010-02-03 Drew Wilson <atwilson@chromium.org> + + Reviewed by Alexey Proskuryakov. + + SharedWorkerScriptLoader should not be an ActiveDOMObject + https://bugs.webkit.org/show_bug.cgi?id=34513 + + * src/SharedWorkerRepository.cpp: + (WebCore::SharedWorkerScriptLoader::SharedWorkerScriptLoader): + Changed SharedWorkerScriptLoader to manage its own lifecycle without using ActiveDOMObject. + (WebCore::SharedWorkerScriptLoader::parentContext): + (WebCore::pendingLoaders): + Now we manually track pending loads so we can shut them down when the parent context shuts down. + (WebCore::SharedWorkerScriptLoader::contextDetached): + Shuts down/frees any pending worker loads. + (WebCore::SharedWorkerScriptLoader::~SharedWorkerScriptLoader): + Marks the SharedWorker object as not having pending activity if there was a load active (handles case where load was pending when parent document exits). + (WebCore::SharedWorkerScriptLoader::load): + (WebCore::SharedWorkerRepository::documentDetached): + Now calls SharedWorkerScriptLoader::contextDetached() to shutdown any pending worker loads. + +2010-02-03 Alexander Pavlov <apavlov@chromium.org> + + Reviewed by Timothy Hatcher. + + [Chromium] Return a consistent set of platforms from WebDevToolsFrontendImpl + https://bugs.webkit.org/show_bug.cgi?id=34523 + + * src/WebDevToolsFrontendImpl.cpp: + (WebKit::WebDevToolsFrontendImpl::jsPlatform): + +2010-02-02 Joel Stanley <joel@jms.id.au> + + Reviewed by David Levin. + + [Chromium] Add API method for setting caret blink frequency. + https://bugs.webkit.org/show_bug.cgi?id=31704 + + This enables the RenderThemeChromiumLinux::setCaretBlinkInterval method + to be called Chromium's API. The API is linux-only as it is currently + the only port to implement RenderTheme::setCaretBlinkInterval. + + * WebKit.gyp: Add WebRenderTheme.{h,cpp} + * public/linux/WebRenderTheme.h: Added. + * src/linux/WebRenderTheme.cpp: Added. + (WebKit::setCaretBlinkInterval): Exposed API + +2010-02-02 Shinichiro Hamaji <hamaji@chromium.org> + + Reviewed by Dimitri Glazkov. + + [Chromium] Implement WebFrameImpl::pageNumberForElementById + https://bugs.webkit.org/show_bug.cgi?id=34471 + + * public/WebFrame.h: + * src/WebFrameImpl.cpp: + (WebKit::WebFrameImpl::pageNumberForElementById): + * src/WebFrameImpl.h: + +2010-02-02 Yury Semikhatsky <yurys@chromium.org> + + Reviewed by Pavel Feldman. + + Upstream DevTools code. + + https://bugs.webkit.org/show_bug.cgi?id=34326 + + * WebKit.gyp: + * src/APUAgentDelegate.h: Added. + * src/BoundObject.cpp: Added. + (WebKit::BoundObject::BoundObject): + (WebKit::BoundObject::~BoundObject): + (WebKit::BoundObject::addProtoFunction): + (WebKit::BoundObject::build): + * src/BoundObject.h: Added. + * src/DebuggerAgent.h: Added. + * src/DebuggerAgentImpl.cpp: Added. + (WebKit::DebuggerAgentImpl::DebuggerAgentImpl): + (WebKit::DebuggerAgentImpl::~DebuggerAgentImpl): + (WebKit::DebuggerAgentImpl::getContextId): + (WebKit::DebuggerAgentImpl::debuggerOutput): + (WebKit::DebuggerAgentImpl::createUtilityContext): + (WebKit::DebuggerAgentImpl::executeUtilityFunction): + (WebKit::DebuggerAgentImpl::executeVoidJavaScript): + (WebKit::DebuggerAgentImpl::page): + * src/DebuggerAgentImpl.h: Added. + (WebKit::DebuggerAgentImpl::setAutoContinueOnException): + (WebKit::DebuggerAgentImpl::autoContinueOnException): + (WebKit::DebuggerAgentImpl::webdevtoolsAgent): + (WebKit::DebuggerAgentImpl::webView): + * src/DebuggerAgentManager.cpp: Added. + (WebKit::DebuggerAgentManager::debugHostDispatchHandler): + (WebKit::DebuggerAgentManager::debugAttach): + (WebKit::DebuggerAgentManager::debugDetach): + (WebKit::DebuggerAgentManager::onV8DebugMessage): + (WebKit::DebuggerAgentManager::pauseScript): + (WebKit::DebuggerAgentManager::executeDebuggerCommand): + (WebKit::DebuggerAgentManager::setMessageLoopDispatchHandler): + (WebKit::DebuggerAgentManager::setHostId): + (WebKit::DebuggerAgentManager::onWebViewClosed): + (WebKit::DebuggerAgentManager::onNavigate): + (WebKit::DebuggerAgentManager::sendCommandToV8): + (WebKit::DebuggerAgentManager::sendContinueCommandToV8): + (WebKit::DebuggerAgentManager::findAgentForCurrentV8Context): + (WebKit::DebuggerAgentManager::debuggerAgentForHostId): + * src/DebuggerAgentManager.h: Added. + (WebKit::DebuggerAgentManager::UtilityContextScope::UtilityContextScope): + (WebKit::DebuggerAgentManager::UtilityContextScope::~UtilityContextScope): + * src/DevToolsRPC.h: Added. + (WebKit::): + (WebKit::DevToolsRPC::Delegate::Delegate): + (WebKit::DevToolsRPC::Delegate::~Delegate): + (WebKit::DevToolsRPC::DevToolsRPC): + (WebKit::DevToolsRPC::~DevToolsRPC): + (WebKit::DevToolsRPC::sendRpcMessage): + * src/DevToolsRPCJS.h: Added. + * src/ProfilerAgent.h: Added. + * src/ProfilerAgentImpl.cpp: Added. + (WebKit::ProfilerAgentImpl::getActiveProfilerModules): + (WebKit::ProfilerAgentImpl::getLogLines): + * src/ProfilerAgentImpl.h: Added. + (WebKit::ProfilerAgentImpl::ProfilerAgentImpl): + (WebKit::ProfilerAgentImpl::~ProfilerAgentImpl): + * src/ToolsAgent.h: Added. + * src/WebDevToolsAgentImpl.cpp: Added. + (WebKit::): + (WebKit::WebDevToolsAgentImpl::WebDevToolsAgentImpl): + (WebKit::WebDevToolsAgentImpl::~WebDevToolsAgentImpl): + (WebKit::WebDevToolsAgentImpl::disposeUtilityContext): + (WebKit::WebDevToolsAgentImpl::unhideResourcesPanelIfNecessary): + (WebKit::WebDevToolsAgentImpl::attach): + (WebKit::WebDevToolsAgentImpl::detach): + (WebKit::WebDevToolsAgentImpl::didNavigate): + (WebKit::WebDevToolsAgentImpl::didCommitProvisionalLoad): + (WebKit::WebDevToolsAgentImpl::didClearWindowObject): + (WebKit::WebDevToolsAgentImpl::forceRepaint): + (WebKit::WebDevToolsAgentImpl::dispatchOnInspectorController): + (WebKit::WebDevToolsAgentImpl::dispatchOnInjectedScript): + (WebKit::WebDevToolsAgentImpl::executeVoidJavaScript): + (WebKit::WebDevToolsAgentImpl::dispatchMessageFromFrontend): + (WebKit::WebDevToolsAgentImpl::inspectElementAt): + (WebKit::WebDevToolsAgentImpl::setRuntimeFeatureEnabled): + (WebKit::WebDevToolsAgentImpl::sendRpcMessage): + (WebKit::WebDevToolsAgentImpl::compileUtilityScripts): + (WebKit::WebDevToolsAgentImpl::initDevToolsAgentHost): + (WebKit::WebDevToolsAgentImpl::createInspectorBackendV8Wrapper): + (WebKit::WebDevToolsAgentImpl::resetInspectorFrontendProxy): + (WebKit::WebDevToolsAgentImpl::setApuAgentEnabled): + (WebKit::WebDevToolsAgentImpl::jsDispatchOnClient): + (WebKit::WebDevToolsAgentImpl::jsDispatchToApu): + (WebKit::WebDevToolsAgentImpl::jsEvaluateOnSelf): + (WebKit::WebDevToolsAgentImpl::jsOnRuntimeFeatureStateChanged): + (WebKit::WebDevToolsAgentImpl::inspectorController): + (WebKit::WebDevToolsAgentImpl::identifierForInitialRequest): + (WebKit::WebDevToolsAgentImpl::willSendRequest): + (WebKit::WebDevToolsAgentImpl::didReceiveData): + (WebKit::WebDevToolsAgentImpl::didReceiveResponse): + (WebKit::WebDevToolsAgentImpl::didFinishLoading): + (WebKit::WebDevToolsAgentImpl::didFailLoading): + (WebKit::WebDevToolsAgentImpl::evaluateInWebInspector): + (WebKit::WebDevToolsAgentImpl::setTimelineProfilingEnabled): + (WebKit::WebDevToolsAgent::create): + (WebKit::WebDevToolsAgent::executeDebuggerCommand): + (WebKit::WebDevToolsAgent::debuggerPauseScript): + (WebKit::WebDevToolsAgent::setMessageLoopDispatchHandler): + (WebKit::WebDevToolsAgent::dispatchMessageFromFrontendOnIOThread): + * src/WebDevToolsAgentImpl.h: Added. + (WebKit::WebDevToolsAgentImpl::hostId): + * src/WebDevToolsFrontendImpl.cpp: Added. + (WebKit::ToV8String): + (WebKit::WebDevToolsFrontend::create): + (WebKit::WebDevToolsFrontendImpl::WebDevToolsFrontendImpl): + (WebKit::WebDevToolsFrontendImpl::~WebDevToolsFrontendImpl): + (WebKit::WebDevToolsFrontendImpl::dispatchMessageFromAgent): + (WebKit::WebDevToolsFrontendImpl::executeScript): + (WebKit::WebDevToolsFrontendImpl::dispatchOnWebInspector): + (WebKit::WebDevToolsFrontendImpl::sendRpcMessage): + (WebKit::WebDevToolsFrontendImpl::contextMenuItemSelected): + (WebKit::WebDevToolsFrontendImpl::contextMenuCleared): + (WebKit::WebDevToolsFrontendImpl::jsLoaded): + (WebKit::WebDevToolsFrontendImpl::jsPlatform): + (WebKit::WebDevToolsFrontendImpl::jsPort): + (WebKit::WebDevToolsFrontendImpl::jsCopyText): + (WebKit::WebDevToolsFrontendImpl::jsActivateWindow): + (WebKit::WebDevToolsFrontendImpl::jsCloseWindow): + (WebKit::WebDevToolsFrontendImpl::jsDockWindow): + (WebKit::WebDevToolsFrontendImpl::jsUndockWindow): + (WebKit::WebDevToolsFrontendImpl::jsLocalizedStringsURL): + (WebKit::WebDevToolsFrontendImpl::jsHiddenPanels): + (WebKit::WebDevToolsFrontendImpl::jsDebuggerCommand): + (WebKit::WebDevToolsFrontendImpl::jsSetting): + (WebKit::WebDevToolsFrontendImpl::jsSetSetting): + (WebKit::WebDevToolsFrontendImpl::jsDebuggerPauseScript): + (WebKit::WebDevToolsFrontendImpl::jsWindowUnloading): + (WebKit::WebDevToolsFrontendImpl::jsShowContextMenu): + * src/WebDevToolsFrontendImpl.h: Added. + (WebKit::WebDevToolsFrontendImpl::MenuProvider::create): + (WebKit::WebDevToolsFrontendImpl::MenuProvider::~MenuProvider): + (WebKit::WebDevToolsFrontendImpl::MenuProvider::disconnect): + (WebKit::WebDevToolsFrontendImpl::MenuProvider::populateContextMenu): + (WebKit::WebDevToolsFrontendImpl::MenuProvider::contextMenuItemSelected): + (WebKit::WebDevToolsFrontendImpl::MenuProvider::contextMenuCleared): + (WebKit::WebDevToolsFrontendImpl::MenuProvider::MenuProvider): + +2010-02-01 Jeremy Orlow <jorlow@chromium.org> + + Reviewed by Darin Fisher. + + [Chromium] Add WebSecurityOrigin::createFromString factory + https://bugs.webkit.org/show_bug.cgi?id=34460 + + * public/WebSecurityOrigin.h: + * src/WebSecurityOrigin.cpp: + (WebKit::WebSecurityOrigin::createFromString): + +2010-02-02 Kent Tamura <tkent@chromium.org> + + Reviewed by Darin Fisher. + + [Chromium] Should not select a word on right-click. + https://bugs.webkit.org/show_bug.cgi?id=33364 + + For non-Mac platforms, do not select a word around the caret when + a context menu is opening. This behavior is not common in non-Mac + platforms, and it prevents pasting with a context menu. + + In order that the spell checker works without the selection, we + introduce WebFrame::selectWordAroundCaret(). We can replace a word + around the caret with selectWordAroundCaret() + replaceSelection(). + + * public/WebFrame.h: Add pure selectWordAroundCaret() declaration. + * src/ContextMenuClientImpl.cpp: + (WebKit::selectMisspelledWord): Move word-selection code to + WebFrameImpl::selectWordAroundPosition(), and clear the selection + on non-Mac. + * src/WebFrameImpl.cpp: + (WebKit::WebFrameImpl::selectWordAroundPosition): + (WebKit::WebFrameImpl::selectWordAroundCaret): + * src/WebFrameImpl.h: Add selectWordAroundCaret() declaration. + +2010-02-01 Shinichiro Hamaji <hamaji@chromium.org> + + Unreviewed attempt to fix the broken build. + + This was introduced in http://trac.webkit.org/changeset/54182 + + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::performMediaPlayerAction): + +2010-01-27 Matt Perry <mpcomplete@chromium.org> + + Reviewed by Eric Seidel. + + Add support for addUserScript to chromium port. + + * public/WebView.h: + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::addUserScript): + (WebKit::WebViewImpl::removeAllUserContent): + * src/WebViewImpl.h: + +2010-01-29 Philippe Normand <pnormand@igalia.com> + + Reviewed by Eric Carlson. + + [GTK] set playbin mute property depending on volume value + https://bugs.webkit.org/show_bug.cgi?id=31586 + + New API in MediaPlayer for mute control + + * public/WebMediaPlayerClient.h: + * src/WebMediaPlayerClientImpl.cpp: + (WebKit::WebMediaPlayerClientImpl::volumeChanged): + (WebKit::WebMediaPlayerClientImpl::muteChanged): + * src/WebMediaPlayerClientImpl.h: + +2010-01-31 Kent Tamura <tkent@chromium.org> + + Reviewed by Jeremy Orlow. + + [Chromium] Fix a bug that a selected word is not recognized as a + spell-check source. + https://bugs.webkit.org/show_bug.cgi?id=33660 + + * src/ContextMenuClientImpl.cpp: + (WebKit::isASingleWord): Use wordBreakIterator(), and correctly check + the return value of textBreakNext(). + +2010-01-29 Jeremy Orlow <jorlow@chromium.org> + + Reviewed by Eric Seidel. + + [Chromium] Clean up WebStorageArea + https://bugs.webkit.org/show_bug.cgi?id=34353 + + Get rid of legacy glue code and fix a typo. + + * public/WebStorageArea.h: + +2010-01-29 Jeremy Orlow <jorlow@chromium.org> + + Reviewed by Dimitri Glazkov. + + A first step towards the Indexed Database API + https://bugs.webkit.org/show_bug.cgi?id=34342 + + Add runtime enable support for Indexed Database API. + + * features.gypi: + * public/WebRuntimeFeatures.h: + * src/WebRuntimeFeatures.cpp: + (WebKit::WebRuntimeFeatures::enableIndexedDatabase): + (WebKit::WebRuntimeFeatures::isIndexedDatabaseEnabled): + +2010-01-29 Yury Semikhatsky <yurys@chromium.org> + + Reviewed by Pavel Feldman. + + Add API methods for loading inspector utility scripts. + + https://bugs.webkit.org/show_bug.cgi?id=34326 + + * public/WebDevToolsAgentClient.h: + (WebKit::WebDevToolsAgentClient::injectedScriptSource): + (WebKit::WebDevToolsAgentClient::injectedScriptDispatcherSource): + +2010-01-29 Darin Fisher <darin@chromium.org> + + Reviewed by Adam Barth. + + Add FrameLoaderClient::allowImages method to allow the client to + overrule image loading policy on a per frame basis. + + https://bugs.webkit.org/show_bug.cgi?id=34225 + + * public/WebFrameClient.h: + (WebKit::WebFrameClient::allowImages): + * public/WebSettings.h: + * src/FrameLoaderClientImpl.cpp: + (WebKit::FrameLoaderClientImpl::allowImages): + * src/FrameLoaderClientImpl.h: + * src/WebSettingsImpl.cpp: + (WebKit::WebSettingsImpl::setImagesEnabled): + * src/WebSettingsImpl.h: + +2010-01-28 Jeremy Orlow <jorlow@chromium.org> + + Reviewed by Darin Fisher. + + StorageNamespaceProxy::copy() should be a no-op + https://bugs.webkit.org/show_bug.cgi?id=34298 + + The comment in the code should make clear why. + + * public/WebViewClient.h: + * src/StorageNamespaceProxy.cpp: + (WebCore::StorageNamespaceProxy::copy): + +2010-01-28 Michael Nordman <michaeln@google.com> + + Reviewed by Alexey Proskuryakov. + + ApplicationCache events should be deferred until after Document onload has fired. + https://bugs.webkit.org/show_bug.cgi?id=29690 + + * src/ApplicationCacheHost.cpp: + (WebCore::ApplicationCacheHost::ApplicationCacheHost): Initialize m_isDeferringEvents to true. + (WebCore::ApplicationCacheHost::notifyDOMApplicationCache): Depending, defer or raise the event. + (WebCore::ApplicationCacheHost::stopDeferringEvents): Raise any deferred events and reset the flag. + +2010-01-27 Aaron Boodman <aa@chromium.org> + + Reviewed by Darin Adler. + + Send full URL and application id of requesting context to Chromium + when checking notification permissions. + + https://bugs.webkit.org/show_bug.cgi?id=34238 + + * public/WebDocument.h: + * src/WebDocument.cpp: + (WebKit::WebDocument::applicationID): + Implement applicationID() method. + + * public/WebNotificationPresenter.h: + * src/NotificationPresenterImpl.cpp: + (WebKit::NotificationPresenterImpl::checkPermission): + * src/NotificationPresenterImpl.h: + Send applicationID and full URL through to Chromium. + +2010-01-27 Darin Fisher <darin@chromium.org> + + Reviewed by Pavel Feldman. + + Expose HistoryItem::documentSequenceNumber + https://bugs.webkit.org/show_bug.cgi?id=34243 + + * public/WebHistoryItem.h: + * src/WebHistoryItem.cpp: + (WebKit::WebHistoryItem::documentSequenceNumber): + (WebKit::WebHistoryItem::setDocumentSequenceNumber): + +2010-01-26 Darin Fisher <darin@chromium.org> + + Reviewed by David Levin. + + Add methods to support running a nested modal loop outside of WebKit. + https://bugs.webkit.org/show_bug.cgi?id=34199 + + * public/WebView.h: + * src/WebViewImpl.cpp: + (WebKit::WebView::willEnterModalLoop): Create PageGroupLoadDeferrer + (WebKit::WebView::didExitModalLoop): Destroy PageGroupLoadDeferrer + +2010-01-27 Darin Fisher <darin@chromium.org> + + Reviewed by Dimitri Glazkov. + + Adding missing WebMutationEvent.cpp file to fix build bustage. + https://bugs.webkit.org/show_bug.cgi?id=33882 + + * public/WebMutationEvent.h: Remove unnecessary constructor. + * src/WebEvent.cpp: Remove unnecessary include of WebMutationEvent.h. + * src/WebMutationEvent.cpp: Added. + +2010-01-27 Jay Campan <jcampan@google.com> + + Reviewed by Darin Fisher. + + Adding EventListeners to the chromium API. + + https://bugs.webkit.org/show_bug.cgi?id=33882 + + * WebKit.gyp: + * public/WebEvent.h: Added. + * public/WebEventListener.h: Added. + * public/WebMutationEvent.h: Added. + * public/WebNode.h: + * public/WebString.h: + (WebKit::operator==): + (WebKit::operator!=): + * src/EventListenerWrapper.cpp: Added. + * src/EventListenerWrapper.h: Added. + * src/WebEvent.cpp: Added. + * src/WebEventListener.cpp: Added. + * src/WebEventListenerPrivate.cpp: Added. + * src/WebEventListenerPrivate.h: Added. + * src/WebNode.cpp: + (WebKit::WebNode::addEventListener): + (WebKit::WebNode::removeEventListener): + * src/WebString.cpp: + (WebKit::WebString::equals): + +2010-01-26 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Darin Fisher. + + Add KeyboardTest to WebKit API tests + https://bugs.webkit.org/show_bug.cgi?id=34178 + + * WebKit.gyp: + * tests/KeyboardTest.cpp: Added. + +2010-01-22 Jeremy Orlow <jorlow@chromium.org> + + Reviewed by Darin Adler. + + Make storage events match the spec. + https://bugs.webkit.org/show_bug.cgi?id=30546 + + Update the storageEvent algorithm to match the change in WebCore. + + * src/StorageAreaProxy.cpp: + (WebCore::StorageAreaProxy::storageEvent): + +2010-01-22 Elliot Glaysher <erg@chromium.org> + + Reviewed by David Levin. + + Chromium: theme selection colors to match gtk theme + Add functions to RenderThemeChromiumLinux to change the selection color + according to the current GTK+ theme. + + Since the change is to the Chromium WebKit API layer, testing is done + in Chromium's test shell (see Chromium side of this patch: + http://codereview.chromium.org/554004) + + https://bugs.webkit.org/show_bug.cgi?id=33921 + + * public/WebView.h: Adds interface to change the selection colors + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::setSelectionColors): Implements new interface. + * src/WebViewImpl.h: + +2010-01-22 Steve VanDeBogart <vandebo@chromium.org> + + Reviewed by David Levin. + + Middle clicking the main scroll bars should not trigger a paste event + in Linux chromium. + https://bugs.webkit.org/show_bug.cgi?id=33062 + + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::mouseUp): + +2010-01-22 Albert J. Wong <ajwong@chromium.org> + + Not reviewed. backout. + + Backout r53705. + Causes ui_tests to timeout, and browser_tests to fail with + TestConnectToBadPort and WindowOpenInvalidExtension. + + * src/FrameLoaderClientImpl.cpp: + (WebKit::FrameLoaderClientImpl::dispatchDidChangeLocationWithinPage): + (WebKit::FrameLoaderClientImpl::postProgressStartedNotification): + (WebKit::FrameLoaderClientImpl::postProgressFinishedNotification): + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::WebViewImpl): + * src/WebViewImpl.h: + +2010-01-22 Peter Kasting <pkasting@google.com> + + Not reviewed, backout. + + Back out r52673, which caused several regressions. + https://bugs.webkit.org/show_bug.cgi?id=32533 + + * src/AutocompletePopupMenuClient.cpp: + (WebKit::AutocompletePopupMenuClient::initialize): + (WebKit::AutocompletePopupMenuClient::popupDidHide): + (WebKit::AutocompletePopupMenuClient::setTextFromItem): + * src/AutocompletePopupMenuClient.h: + +2010-01-21 Jeremy Orlow <jorlow@chromium.org> + + Reviewed by Darin Fisher. + + The Chromium WebKit API needs to expose storage event related data + https://bugs.webkit.org/show_bug.cgi?id=33985 + + setItem and removeItem on WebStorageArea need to expose what the previous + value was for the key being modified. Clear needs to return whether it + actually cleared anything. + + * public/WebStorageArea.h: + (WebKit::WebStorageArea::setItem): + (WebKit::WebStorageArea::removeItem): + (WebKit::WebStorageArea::clear): + * src/StorageAreaProxy.cpp: + (WebCore::StorageAreaProxy::StorageAreaProxy): + (WebCore::StorageAreaProxy::setItem): + (WebCore::StorageAreaProxy::removeItem): + (WebCore::StorageAreaProxy::clear): + (WebCore::StorageAreaProxy::storageEvent): + * src/StorageAreaProxy.h: + * src/StorageNamespaceProxy.cpp: + (WebCore::StorageNamespace::localStorageNamespace): + (WebCore::StorageNamespace::sessionStorageNamespace): + (WebCore::StorageNamespaceProxy::StorageNamespaceProxy): + (WebCore::StorageNamespaceProxy::copy): + (WebCore::StorageNamespaceProxy::storageArea): + * src/StorageNamespaceProxy.h: + * src/WebStorageAreaImpl.cpp: + (WebKit::WebStorageAreaImpl::setItem): + (WebKit::WebStorageAreaImpl::removeItem): + (WebKit::WebStorageAreaImpl::clear): + * src/WebStorageAreaImpl.h: + +2010-01-21 Darin Fisher <darin@chromium.org> + + Reviewed by David Levin. + + [Chromium] spurious WebViewClient::didStopLoading if changing + location.hash while a subframe is still loading + + https://bugs.webkit.org/show_bug.cgi?id=33884 + + This is a refinement of http://trac.webkit.org/changeset/51548 + + * src/FrameLoaderClientImpl.cpp: + (WebKit::FrameLoaderClientImpl::dispatchDidChangeLocationWithinPage): + (WebKit::FrameLoaderClientImpl::postProgressStartedNotification): + (WebKit::FrameLoaderClientImpl::postProgressFinishedNotification): + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::WebViewImpl): + (WebKit::WebViewImpl::didStartLoading): + (WebKit::WebViewImpl::didStopLoading): + * src/WebViewImpl.h: + +2010-01-21 Adam Barth <abarth@webkit.org> + + Unreviewed. Added a blank line requested by the great an powerful + fishd. + + * public/WebFrameClient.h: + +2010-01-21 Adam Barth <abarth@webkit.org> + + Reviewed by Eric Seidel. + + [chromium] Add allowPlugins callback to allow per-site enabling of plugins + https://bugs.webkit.org/show_bug.cgi?id=33974 + + Forward the new allowPlugins callback to WebKitClient so that it can + make the policy decision. + + * public/WebFrameClient.h: + (WebKit::WebFrameClient::allowPlugins): + * src/FrameLoaderClientImpl.cpp: + (WebKit::FrameLoaderClientImpl::allowJavaScript): + (WebKit::FrameLoaderClientImpl::allowPlugins): + * src/FrameLoaderClientImpl.h: + +2010-01-21 James Robinson <jamesr@chromium.org> + + Reviewed by Darin Fisher. + + Bumps the refcount when WebNode::toElement/toConstElement are called. + https://bugs.webkit.org/show_bug.cgi?id=33977 + + Ensures that when a wrapper around a WebNode is create via the + toElement() or toConstElement() calls that the refcount on the WebNode + is increased, by forcing a call to WebNode::assign(). This is needed + so that the following code: + { + WebNode n = someNode(); + WebElement e = n.toElement<WebElement>(); + } + does not decrease the overall refcount on the Node that someNode() + returns. + + This caused crashes in the 'Save page as..' feature. + + * public/WebNode.h: + (WebKit::WebNode::toElement): + (WebKit::WebNode::toConstElement): + +2010-01-21 Michael Nordman <michaeln@google.com> + + Reviewed by Darin Fisher. + + Adds WebKit::WebDataSource::applicationCacheHost() to the API. + https://bugs.webkit.org/show_bug.cgi?id=33880 + + * WebKit.gyp: + * public/WebDataSource.h: + * src/ApplicationCacheHost.cpp: + * src/ApplicationCacheHostInternal.h: Copied from WebKit/chromium/src/ApplicationCacheHost.cpp. + (WebCore::ApplicationCacheHostInternal::notifyEventListener): + (WebCore::ApplicationCacheHostInternal::toWebApplicationCacheHost): + * src/WebDataSourceImpl.cpp: + (WebKit::WebDataSourceImpl::applicationCacheHost): + * src/WebDataSourceImpl.h: + +2010-01-21 Eric Uhrhane <ericu@chromium.org> + + Reviewed by Dmitry Titov. + + Add changes missing from r53595, without which Chromium has no database. + + https://bugs.webkit.org/show_bug.cgi?id=33966 + + No new tests - fixes database layout tests in Chromium. + + * src/WebRuntimeFeatures.cpp: + (WebKit::WebRuntimeFeatures::enableDatabase): + (WebKit::WebRuntimeFeatures::isDatabaseEnabled): + +2010-01-21 Kenneth Russell <kbr@google.com> + + Reviewed by Oliver Hunt. + + [Chromium] Implement texSubImage2D taking WebGLArray + https://bugs.webkit.org/show_bug.cgi?id=33932 + + * src/GraphicsContext3D.cpp: + (WebCore::GraphicsContext3D::texSubImage2D): + +2010-01-20 Vitaly Repeshko <vitalyr@chromium.org> + + Reviewed by Pavel Feldman. + + [V8] Support SerializedScriptValue. + https://bugs.webkit.org/show_bug.cgi?id=32920 + http://crbug.com/30620 + + Updated uses of SerializedScriptValue: + * src/PlatformMessagePortChannel.cpp: + (WebCore::PlatformMessagePortChannel::postMessageToRemote): + (WebCore::PlatformMessagePortChannel::tryGetMessageFromRemote): + * src/WebWorkerBase.cpp: + (WebKit::WebWorkerBase::postMessageToWorkerObject): + * src/WebWorkerClientImpl.cpp: + (WebKit::WebWorkerClientImpl::postMessageToWorkerContext): + (WebKit::WebWorkerClientImpl::postMessageToWorkerObjectTask): + * src/WebWorkerImpl.cpp: + (WebKit::WebWorkerImpl::postMessageToWorkerContextTask): + +2010-01-20 Shinichiro Hamaji <hamaji@chromium.org> + + Reviewed by Darin Fisher. + + [Chromium] computePageRectsForFrame seems to be unnecessary + https://bugs.webkit.org/show_bug.cgi?id=33881 + + * src/WebFrameImpl.cpp: Stop including FrameChromium.h + +2010-01-19 Jon Honeycutt <jhoneycutt@apple.com> + + Chromium build fix. + + * public/WebAccessibilityRole.h: + (WebKit::): + Correct enum names. + + * src/LocalizedStrings.cpp: + (WebCore::AXMenuListPopupActionVerb): + Stubbed. + (WebCore::AXMenuListActionVerb): + Stubbed. + +2010-01-19 Jon Honeycutt <jhoneycutt@apple.com> + + Chromium build fix. + + * public/WebAccessibilityRole.h: + (WebKit::): + + * src/AssertMatchingEnums.cpp: + +2010-01-18 Jonathan Dixon <joth@chromium.org> + + Reviewed by Adam Barth. + + Add support for enabling navigator.geolocation at runtime in the V8 bindings. + Adds the [EnabledAtRuntime] modifier to the navigator IDL. + https://bugs.webkit.org/show_bug.cgi?id=33467 + + * public/WebRuntimeFeatures.h: + * src/WebRuntimeFeatures.cpp: + (WebKit::WebRuntimeFeatures::enableGeolocation): + (WebKit::WebRuntimeFeatures::isGeolocationEnabled): + +2010-01-17 Kent Tamura <tkent@chromium.org> + + Reviewed by Shinichiro Hamaji. + + [Chromium] Remove an old runFileChooser() method. + https://bugs.webkit.org/show_bug.cgi?id=33778 + + Chromium code switched to new runFileChooser() introduced by + r53269. The old one is not needed anymore. + + * public/WebViewClient.h: + * src/ChromeClientImpl.cpp: + (WebKit::ChromeClientImpl::runOpenPanel): + +2010-01-15 Eric Seidel <eric@webkit.org> + + No review, rolling out r53344. + http://trac.webkit.org/changeset/53344 + https://bugs.webkit.org/show_bug.cgi?id=32920 + + Broke the Chromium Mac builder. + + * src/PlatformMessagePortChannel.cpp: + (WebCore::PlatformMessagePortChannel::postMessageToRemote): + (WebCore::PlatformMessagePortChannel::tryGetMessageFromRemote): + * src/WebWorkerBase.cpp: + (WebKit::WebWorkerBase::postMessageToWorkerObject): + * src/WebWorkerClientImpl.cpp: + (WebKit::WebWorkerClientImpl::postMessageToWorkerContext): + (WebKit::WebWorkerClientImpl::postMessageToWorkerObjectTask): + * src/WebWorkerImpl.cpp: + (WebKit::WebWorkerImpl::postMessageToWorkerContextTask): + +2010-01-15 Vitaly Repeshko <vitalyr@chromium.org> + + Reviewed by David Levin. + + [V8] Support SerializedScriptValue. + https://bugs.webkit.org/show_bug.cgi?id=32920 + http://crbug.com/30620 + + Updated uses of SerializedScriptValue: + * src/PlatformMessagePortChannel.cpp: + (WebCore::PlatformMessagePortChannel::postMessageToRemote): + (WebCore::PlatformMessagePortChannel::tryGetMessageFromRemote): + * src/WebWorkerBase.cpp: + (WebKit::WebWorkerBase::postMessageToWorkerObject): + * src/WebWorkerClientImpl.cpp: + (WebKit::WebWorkerClientImpl::postMessageToWorkerContext): + (WebKit::WebWorkerClientImpl::postMessageToWorkerObjectTask): + * src/WebWorkerImpl.cpp: + (WebKit::WebWorkerImpl::postMessageToWorkerContextTask): + +2010-01-14 Jeremy Orlow <jorlow@chromium.org> + + Reviewed by Oliver Hunt. + + [Chromium] Forgot to adopt a ref counted object in StorageNamespaceProxy + https://bugs.webkit.org/show_bug.cgi?id=33704 + + * src/StorageNamespaceProxy.cpp: + (WebCore::StorageNamespace::localStorageNamespace): + (WebCore::StorageNamespace::sessionStorageNamespace): + +2010-01-14 Marcus Bulach <bulach@chromium.org> + + Reviewed by Dimitri Glazkov. + + Adds WebKit::WebSecurityOrigin::createFromDatabaseIdentifier. + https://bugs.webkit.org/show_bug.cgi?id=33648 + + * public/WebSecurityOrigin.h: + * src/WebSecurityOrigin.cpp: + (WebKit::WebSecurityOrigin::createFromDatabaseIdentifier): + +2010-01-14 Brian Weinstein <bweinstein@apple.com> + + Reviewed by Adam Roben. + + Drag and Drop source/destination code needs cleanup. + <https://bugs.webkit.org/show_bug.cgi?id=33691>. + + Update to new way of calling sourceOperation. + + * src/DragClientImpl.cpp: + (WebKit::DragClientImpl::startDrag): + +2010-01-14 Nate Chapin <japhet@chromium.org> + + Reviewed by Dimitri Glazkov. + + Remove references to V8DOMWrapper::convertToNative*(). + + https://bugs.webkit.org/show_bug.cgi?id=33677 + + * src/WebBindings.cpp: + (WebKit::getDragDataImpl): + (WebKit::getRangeImpl): + +2010-01-14 Kent Tamura <tkent@chromium.org> + + Reviewed by Darin Fisher. + + Introduce WebFileChooserParams to convey parameters for + WebViewClient::runFileChooser(), and add new parameters to it. + https://bugs.webkit.org/show_bug.cgi?id=32473 + + The new parameters are + - selected file names + - "accept" attribute value + + * WebKit.gyp: Add WebFileChooserParams.h + * public/WebFileChooserParams.h: Added. + * public/WebViewClient.h: + (WebKit::WebViewClient::runFileChooser): + Add runFileChooser() with WebFileChooserParams, and mark the old one deprecated. + * src/ChromeClientImpl.cpp: + (WebKit::ChromeClientImpl::runOpenPanel): + Call the new runFileChooser() first, then call the old + runFileChooser() if the new one failed. + +2010-01-13 Kenneth Russell <kbr@google.com> + + Reviewed by Oliver Hunt. + + Need to implement WebGLContextAttributes + https://bugs.webkit.org/show_bug.cgi?id=31169 + + Added the WebGLContextAttributes class and custom JavaScript + bindings to accept a native object as the second argument to + getContext("experimental-webgl") per the WebGL specification. + Added GraphicsContext3D::Attributes struct to isolate DOM and + graphics layers. Added getContextAttributes() to + WebGLRenderingContext. Added test case ensuring that context + attributes can be passed down and returned. Tested in Safari and + Chromium. The attributes will be hooked up to the creation of the + OpenGL context in bug 33416. + + * src/GraphicsContext3D.cpp: + (WebCore::GraphicsContext3DInternal::GraphicsContext3DInternal): + (WebCore::GraphicsContext3DInternal::getContextAttributes): + (WebCore::GraphicsContext3D::create): + (WebCore::GraphicsContext3D::GraphicsContext3D): + (WebCore::GraphicsContext3D::getContextAttributes): + +2010-01-13 Jon Honeycutt <jhoneycutt@apple.com> + + MSAA: selected, selectable, extended selectable, and multiple + selectable states are not reported + + https://bugs.webkit.org/show_bug.cgi?id=33574 + <rdar://problem/7536826> + + Reviewed by Darin Adler. + + * public/WebAccessibilityObject.h: + Update for WebCore::AccessibilityObject function rename. + + * src/WebAccessibilityObject.cpp: + (WebKit::WebAccessibilityObject::isMultiSelectable): + Ditto. + +2010-01-13 Jeremy Orlow <jorlow@chromium.org> + + Reviewed by Darin Fisher. + + [Chromium] Move getSessionStorageNamespace from WebKitClient to WebViewClient + https://bugs.webkit.org/show_bug.cgi?id=33492 + + * public/WebKitClient.h: + * public/WebViewClient.h: + (WebKit::WebViewClient::createSessionStorageNamespace): + * src/StorageNamespaceProxy.cpp: + (WebCore::StorageNamespace::sessionStorageNamespace): + +2010-01-13 Jeremy Orlow <jorlow@chromium.org> + + No reviewer. More or less a build fix. My 53180 broke some + stuff on the Chromium port so I'm reverting. + + * public/WebKitClient.h: + * public/WebViewClient.h: + * src/StorageNamespaceProxy.cpp: + (WebCore::StorageNamespace::sessionStorageNamespace): + +2010-01-11 Jeremy Orlow <jorlow@chromium.org> + + Reviewed by Darin Fisher. + + [Chromium] Move getSessionStorageNamespace from WebKitClient to WebViewClient + https://bugs.webkit.org/show_bug.cgi?id=33492 + + * public/WebKitClient.h: + * public/WebViewClient.h: + (WebKit::WebViewClient::getSessionStorageNamespace): + * src/StorageNamespaceProxy.cpp: + (WebCore::StorageNamespace::sessionStorageNamespace): + +2010-01-11 Darin Fisher <darin@chromium.org> + + Reviewed by Dimitri Glazkov. + + [Chromium] Re-work webkit_unit_tests so that WebKit is initialized only once + https://bugs.webkit.org/show_bug.cgi?id=33504 + + * WebKit.gyp: + * tests/KURLTest.cpp: + (ComponentCase::TEST): + * tests/RunAllTests.cpp: Added. + (main): + * tests/WebKitTest.h: Removed. + +2010-01-09 Adam Barth <abarth@webkit.org> + + Reviewed by Darin Adler. + + ScriptController::isEnabled needs to be renamed + https://bugs.webkit.org/show_bug.cgi?id=32063 + + Rename ScriptController::isEnabled to + ScriptController::canExecuteScripts. + + * src/WebFrameImpl.cpp: + (WebKit::WebFrameImpl::bindToWindowObject): + +2010-01-08 Daniel Bates <dbates@webkit.org> + + Reviewed by Adam Barth. + + https://bugs.webkit.org/show_bug.cgi?id=33417 + + Cleans up style errors exposed by the patch for bug #33198. + + No functionality was changed. So, no new tests. + + * src/GraphicsContext3D.cpp: + +2010-01-08 Darin Fisher <darin@chromium.org> + + Reviewed by Dimitri Glazkov. + + [Chromium] Upstream webkit unit tests from the chromium repository + https://bugs.webkit.org/show_bug.cgi?id=33351 + + This adds one such test (for KURL) and sets up the test framework. + + Switch WebKit to build a static library on all platforms. Add a + webkit_unit_tests executable target that runs the unit tests and also + ensures that we don't have any missing symbols (a function that WebKit + as a shared library used to serve). + + Changes chromium_src_dir to ../../WebKit/chromium to match how + WebCore.gyp defines that variable. + + * WebKit.gyp: + * public/WebKitClient.h: + (WebKit::WebKitClient::getPluginList): Remove bogus trailing semi-colon. + (WebKit::WebKitClient::decrementStatsCounter): Remove bogus trailing semi-colon. + (WebKit::WebKitClient::incrementStatsCounter): Remove bogus trailing semi-colon. + (WebKit::WebKitClient::traceEventBegin): Remove bogus trailing semi-colon. + (WebKit::WebKitClient::traceEventEnd): Remove bogus trailing semi-colon. + (WebKit::WebKitClient::histogramCounts): Remove bogus trailing semi-colon. + * tests: Added. + * tests/KURLTest.cpp: Added. + * tests/WebKitTest.h: Added. + +2010-01-07 Mike Belshe <mbelshe@chromium.org> + + Reviewed by Darin Adler. + + Fix Spdy casing to match style guide. + + https://bugs.webkit.org/show_bug.cgi?id=33326 + + * public/WebURLResponse.h: + * src/WebURLResponse.cpp: + (WebKit::WebURLResponse::wasFetchedViaSPDY): + (WebKit::WebURLResponse::setWasFetchedViaSPDY): + +2010-01-07 Daniel Bates <dbates@rim.com> + + Reviewed by Eric Seidel. + + https://bugs.webkit.org/show_bug.cgi?id=32987 + + Added ENABLE_XHTMLMP flag. Disabled by default. + + * features.gypi: + +2010-01-07 Adam Barth <abarth@webkit.org> + + No review, rolling out r52847. + http://trac.webkit.org/changeset/52847 + https://bugs.webkit.org/show_bug.cgi?id=33232 + + Might have caused a perf regression. + + * src/FrameLoaderClientImpl.cpp: + (WebKit::FrameLoaderClientImpl::detachedFromParent3): + +2010-01-06 Mike Belshe <mike@belshe.com> + + Add a flag to the ResourceResponse for tracking if a request was + fetched via SPDY. This is plumbed through so that we can inform + a webpage via JavaScript if it was fecthed via the experimental + SPDY protocol. + + https://bugs.webkit.org/show_bug.cgi?id=33186 + + * public/WebURLResponse.h: + * src/WebURLResponse.cpp: + (WebKit::WebURLResponse::wasFetchedViaSpdy): + (WebKit::WebURLResponse::setWasFetchedViaSpdy): + +2010-01-06 Darin Fisher <darin@chromium.org> + + Fix release build bustage. + + * src/WebKit.cpp: Need to include Logging.h + +2010-01-05 Darin Fisher <darin@chromium.org> + + Reviewed by Adam Barth. + + [Chromium] Expose more APIs to eliminate WebCore usage in Chromium. + https://bugs.webkit.org/show_bug.cgi?id=33249 + + * WebKit.gyp: + * public/WebFrame.h: + * public/WebGlyphCache.h: Added. + * public/WebKit.h: + * src/WebFrameImpl.cpp: + (WebKit::WebFrame::instanceCount): + (WebKit::WebFrameImpl::WebFrameImpl): + (WebKit::WebFrameImpl::~WebFrameImpl): + * src/WebFrameImpl.h: + * src/WebGlyphCache.cpp: Added. + (WebKit::WebGlyphCache::pageCount): + * src/WebKit.cpp: + (WebKit::enableLogChannel): + +2010-01-05 Adam Barth <abarth@webkit.org> + + Reviewed by Dimitri Glazkov. + + [v8] Move V8DOMWindowShell to ScriptController + https://bugs.webkit.org/show_bug.cgi?id=33232 + + Update FrameLoaderClientImpl.cpp to call clearForClose on + ScriptController instead of on V8Proxy. + + * src/FrameLoaderClientImpl.cpp: + (WebKit::FrameLoaderClientImpl::detachedFromParent3): + +2010-01-05 Rachel Petterson <rlp@google.com> + + Reviewed by Adam Barth. + + Matches the texImage2D and texSubImage2D functions to their + declarations. Elminates uncessary versions of those functions. + https://bugs.webkit.org/show_bug.cgi?id=31562 + Also bug: https://bugs.webkit.org/show_bug.cgi?id=31493 + + * src/GraphicsContext3D.cpp: + (WebCore::GraphicsContext3D::texImage2D): + (WebCore::GraphicsContext3D::texSubImage2D): + +2010-01-04 Maciej Stachowiak <mjs@apple.com> + + Reviewed by Darin Fisher. + + Reorganize, document and rename OS() platform macros. + https://bugs.webkit.org/show_bug.cgi?id=33198 + + Adapt to name changes. + + * src/ChromiumBridge.cpp: + * src/EditorClientImpl.cpp: + (WebKit::EditorClientImpl::isSelectTrailingWhitespaceEnabled): + (WebKit::): + (WebKit::EditorClientImpl::handleEditingKeyboardEvent): + * src/FrameLoaderClientImpl.cpp: + (WebKit::FrameLoaderClientImpl::createPlugin): + * src/GraphicsContext3D.cpp: + (WebCore::GraphicsContext3DInternal::GraphicsContext3DInternal): + (WebCore::GraphicsContext3DInternal::~GraphicsContext3DInternal): + (WebCore::GraphicsContext3DInternal::makeContextCurrent): + * src/WebFrameImpl.cpp: + (WebKit::WebFrameImpl::selectionAsText): + (WebKit::WebFrameImpl::printPage): + * src/WebPluginContainerImpl.cpp: + (WebKit::WebPluginContainerImpl::handleMouseEvent): + (WebKit::WebPluginContainerImpl::handleKeyboardEvent): + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::mouseDown): + (WebKit::WebViewImpl::mouseContextMenu): + (WebKit::WebViewImpl::mouseUp): + (WebKit::WebViewImpl::keyEvent): + (WebKit::WebViewImpl::sendContextMenuEvent): + (WebKit::WebViewImpl::setScrollbarColors): + (WebKit::WebViewImpl::navigationPolicyFromMouseEvent): + +2010-01-04 Darin Fisher <darin@chromium.org> + + Reviewed by Eric Seidel. + + [Chromium] Expose more DOM methods to support LayoutTests + https://bugs.webkit.org/show_bug.cgi?id=33185 + + * public/WebDocument.h: Adds documentElement method. + * public/WebElement.h: Adds innerText method. + * public/WebFrame.h: Adds renderTreeAsText and counterValueForElementById + methods, and fixes a few whitespace issues. + * src/WebDocument.cpp: + (WebKit::WebDocument::documentElement): + * src/WebElement.cpp: + (WebKit::WebElement::innerText): + * src/WebFrameImpl.cpp: + (WebKit::WebFrameImpl::clearName): + (WebKit::WebFrameImpl::renderTreeAsText): + (WebKit::WebFrameImpl::counterValueForElementById): + * src/WebFrameImpl.h: + +2010-01-04 Darin Fisher <darin@chromium.org> + + Fix Chromium build bustage. + + * src/WebAnimationControllerImpl.h: + +2010-01-04 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Darin Fisher. + + Adding WebAnimationController to chromium's WebKit API. + + https://bugs.webkit.org/show_bug.cgi?id=32870 + + * WebKit.gyp: + * public/WebAnimationController.h: Added. + (WebKit::WebAnimationController::~WebAnimationController): + * public/WebFrame.h: + * src/WebAnimationControllerImpl.cpp: Added. + (WebKit::WebAnimationControllerImpl::WebAnimationControllerImpl): + (WebKit::WebAnimationControllerImpl::pauseAnimationAtTime): + (WebKit::WebAnimationControllerImpl::pauseTransitionAtTime): + (WebKit::WebAnimationControllerImpl::numberOfActiveAnimations): + * src/WebAnimationControllerImpl.h: Added. + (WebKit::WebAnimationControllerImpl::~WebAnimationControllerImpl): + * src/WebFrameImpl.cpp: + (WebKit::WebFrameImpl::animationController): + (WebKit::WebFrameImpl::WebFrameImpl): + * src/WebFrameImpl.h: + +2010-01-04 Jay Campan <jcampan@google.com> + + Reviewed by Darin Fisher + + Adding more DOM API methods. They are needed for the upcoming + translate feature. + + * public/WebElement.h: + * public/WebNode.h: + * src/WebElement.cpp: + (WebKit::WebElement::tagName): + (WebKit::WebElement::setAttribute): + * src/WebNode.cpp: + (WebKit::WebNode::setNodeValue): + +2010-01-03 Adam Barth <abarth@webkit.org> + + Reviewed by Eric Seidel. + + [Chromium] Implement CookieJarChromium::cookiesEnabled + https://bugs.webkit.org/show_bug.cgi?id=33123 + + Call out to the webKitClient() to see if cookies are enabled. Also + remove some straggling references to policyURL! + + * public/WebKitClient.h: + (WebKit::WebKitClient::setCookies): + (WebKit::WebKitClient::cookies): + (WebKit::WebKitClient::rawCookies): + (WebKit::WebKitClient::cookiesEnabled): + * src/ChromiumBridge.cpp: + (WebCore::ChromiumBridge::cookiesEnabled): + +2010-01-03 Adam Barth <abarth@webkit.org> + + Reviewed by Eric Seidel. + + [Chromium] Remove evaluateInNewContext (it's useless) + https://bugs.webkit.org/show_bug.cgi?id=33068 + + This function has no clients and makes life complicated. Isolated + worlds won out over NewContext and there's not really any going back + now. + + * public/WebFrame.h: + * src/FrameLoaderClientImpl.h: + * src/WebFrameImpl.cpp: + * src/WebFrameImpl.h: + +2009-12-30 Darin Fisher <darin@chromium.org> + + Reviewed by David Levin. + + [Chromium] Delete ResourceRequest::securityInfo + https://bugs.webkit.org/show_bug.cgi?id=26847 + + * src/WebWorkerBase.cpp: + (WebKit::WebWorkerBase::initializeLoader): + +2009-12-30 Albert J. Wong <ajwong@chromium.org> + + Not reviewed. Trivial Chromium build fix. + + Add static_cast<unsigned>() to fix signed/unsigned comparison warning. + + * src/AutocompletePopupMenuClient.cpp: + (WebKit::AutocompletePopupMenuClient::selectionChanged): + +2009-12-30 Zelidrag Hornung <zelidrag@chromium.org> + + Reviewed by Dimitri Glazkov. + + Autocomplete in Chromium now offers suggestions within the input element as a user + a) types text that produces some autocomplete suggestions, and + b) scrolls through suggested values in the menu + The suggested value is rendered but not exposed through JS unti the + user makes the final selection. + + No new tests since this new functionality (autocomplete suggestions) + is intentionally hidden from everything else than renderer. + + * src/AutocompletePopupMenuClient.cpp: + (WebKit::AutocompletePopupMenuClient::initialize): + (WebKit::AutocompletePopupMenuClient::setInitialAutocompleteValue): + (WebKit::AutocompletePopupMenuClient::selectionChanged): + (WebKit::AutocompletePopupMenuClient::popupDidHide): + (WebKit::AutocompletePopupMenuClient::setTextFromItem): + (WebKit::AutocompletePopupMenuClient::resetLastFieldValue): + * src/AutocompletePopupMenuClient.h: + + +2009-12-28 Kinuko Yasuda <kinuko@chromium.org> + + Reviewed by Maciej Stachowiak. + + Fixed isKeypadEvent behavior for chromium/Mac to correctly report + keyLocation as DOM_KEY_LOCATION_NUMPAD for numeric pad key events. + https://bugs.webkit.org/show_bug.cgi?id=28247 + + Test: fast/events/keydown-numpad-keys.html + + * src/mac/WebInputEventFactory.mm: + (WebKit::isKeypadEvent): + +2009-12-22 Kenneth Russell <kbr@google.com> + + Reviewed by Eric Seidel. + + [Chromium] Garbage in transparent regions of images uploaded as textures + https://bugs.webkit.org/show_bug.cgi?id=32888 + + Test: fast/canvas/webgl/bug-32888.html (works in Safari / DumpRenderTree) + + * src/GraphicsContext3D.cpp: + (WebCore::GraphicsContext3D::texImage2D): + +2009-12-22 Adam Langley <agl@google.com> + + Build fix: not reviewed. + + r52504 (https://bugs.webkit.org/show_bug.cgi?id=32845) broke the + Chromium build on Windows and Mac due to a misplaced #endif. The + buildbot didn't find the problem because it runs on Linux. + + Have verified this patch with the author of the above. + + * src/GraphicsContext3D.cpp: + +2009-12-22 Kenneth Russell <kbr@google.com> + + Reviewed by Eric Seidel. + + [Chromium] WebGL crashes intermittently on Linux + https://bugs.webkit.org/show_bug.cgi?id=32845 + + The dlclose'ing of libGL.so.1 and dlopen'ing of it each time a + GraphicsContext3D was created was occasionally causing it to be + re-mapped at a different base address. Since GLEW is not + re-initialized every time, primarily for performance reasons, its + cached function pointers were pointing to garbage. Stopped closing + and re-opening libGL.so.1 each time; now it is loaded lazily, when + the first 3D context is created. Also reused the X display + connection since the GLX routines' correctness might hinge upon it + not resulting in a change of GL implementation. + + * src/GraphicsContext3D.cpp: + (WebCore::GraphicsContext3DInternal::GLConnection::chooseFBConfig): + (WebCore::GraphicsContext3DInternal::GLConnection::createNewContext): + (WebCore::GraphicsContext3DInternal::GLConnection::createPbuffer): + (WebCore::GraphicsContext3DInternal::GLConnection::destroyPbuffer): + (WebCore::GraphicsContext3DInternal::GLConnection::makeCurrent): + (WebCore::GraphicsContext3DInternal::GLConnection::destroyContext): + (WebCore::GraphicsContext3DInternal::GLConnection::getCurrentContext): + (WebCore::GraphicsContext3DInternal::GLConnection::GLConnection): + (WebCore::GraphicsContext3DInternal::GLConnection::tryLoad): + (WebCore::GraphicsContext3DInternal::GLConnection::create): + (WebCore::GraphicsContext3DInternal::GLConnection::~GLConnection): + (WebCore::GraphicsContext3DInternal::GraphicsContext3DInternal): + (WebCore::GraphicsContext3DInternal::~GraphicsContext3DInternal): + (WebCore::GraphicsContext3DInternal::makeContextCurrent): + +2009-12-22 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Darin Fisher. + + autoComplete and getElementById methods for WebKit API + + https://bugs.webkit.org/show_bug.cgi?id=32866 + + * public/WebDocument.h: + * public/WebInputElement.h: + * src/WebDocument.cpp: + (WebKit::WebDocument::getElementById): + * src/WebInputElement.cpp: + (WebKit::WebInputElement::autoComplete): + +2009-12-18 Kenneth Russell <kbr@google.com> + + Reviewed by Darin Fisher. + + [Chromium] Eliminate redundant data copy in GraphicsContext3D readback + https://bugs.webkit.org/show_bug.cgi?id=32763 + + Eliminated useless creation of a CGBitmapContext and from there a + CGImage. Now create CGImage directly from data. Also changed + readPixels parameters and CGImage alpha info to try to avoid byte + swapping, and disabled interpolation when drawing the GL content. + Some test cases run twice as fast with these changes, though more + work is needed to achieve desired performance. + + No test case; performance optimization only. Ran WebGL demos from + Khronos site to verify changes. + + * src/GraphicsContext3D.cpp: + (WebCore::GraphicsContext3DInternal::GraphicsContext3DInternal): + (WebCore::GraphicsContext3DInternal::~GraphicsContext3DInternal): + (WebCore::GraphicsContext3DInternal::reshape): + (WebCore::GraphicsContext3DInternal::beginPaint): + +2009-12-18 Peter Kasting <pkasting@google.com> + + Reviewed by Adam Barth. + + Chromium build fix + https://bugs.webkit.org/show_bug.cgi?id=32756 + + * public/WebAccessibilityRole.h: + (WebKit::): + * src/AssertMatchingEnums.cpp: + +2009-12-18 Adam Roben <aroben@apple.com> + + Chromium build fix + + * src/ChromiumBridge.cpp: + * src/WebPluginContainerImpl.cpp: + * src/WebViewImpl.cpp: + Added #includes. + +2009-12-17 Eric Seidel <eric@webkit.org> + + No review, rolling out r52291. + http://trac.webkit.org/changeset/52291 + https://bugs.webkit.org/show_bug.cgi?id=32618 + + Darin Fisher points out that this will likely break + the SSL security indicator in Chromium. Rolling out for now. + + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::WebViewImpl): + +2009-12-17 Alexander Pavlov <apavlov@chromium.org> + + Reviewed by Eric Seidel. + + Disable memory cache client calls so that a new identifier isn't created + for the same resource on reload. + + With the calls enabled, duplicate entries for cached resources are created + in the Web Inspector. Safari for Windows disables the calls near the point of the + Frame instance creation, and we just follow this for Chromium. + https://bugs.webkit.org/show_bug.cgi?id=32618 + + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::WebViewImpl): + +2009-12-17 Yaar Schnitman <yaar@chromium.org> + + Reviewed by Darin Fisher. + + Added WebPageSerializer to WebKit API and enriched the WebNode hierarchy to support + downstream unit-testing of serialization. + + WebPageSerializer was adapted from Chromium's dom_serializer, originally authored by Johnny Ding. + + https://bugs.webkit.org/show_bug.cgi?id=31737 + + * WebKit.gyp: + * public/WebDocument.h: Added. + (WebKit::WebDocument::WebDocument): + (WebKit::WebDocument::operator=): + (WebKit::WebDocument::assign): + * public/WebElement.h: + * public/WebFormElement.h: + (WebKit::WebFormElement::operator=): + * public/WebFrame.h: + * public/WebNode.h: + (WebKit::WebNode::): + (WebKit::WebNode::toConstElement): + * public/WebNodeCollection.h: Added. + (WebKit::WebNodeCollection::~WebNodeCollection): + (WebKit::WebNodeCollection::WebNodeCollection): + (WebKit::WebNodeCollection::operator=): + * public/WebNodeList.h: Added. + (WebKit::WebNodeList::~WebNodeList): + (WebKit::WebNodeList::WebNodeList): + (WebKit::WebNodeList::operator=): + * public/WebPageSerializer.h: Added. + * public/WebPageSerializerClient.h: Added. + (WebKit::WebPageSerializerClient::): + (WebKit::WebPageSerializerClient::WebPageSerializerClient): + (WebKit::WebPageSerializerClient::~WebPageSerializerClient): + * public/WebString.h: + * public/WebView.h: + * src/AssertMatchingEnums.cpp: + * src/DOMUtilitiesPrivate.cpp: + (WebKit::elementHasLegalLinkAttribute): + * src/DOMUtilitiesPrivate.h: + * src/WebDocument.cpp: Added. + (WebKit::WebDocument::WebDocument): + (WebKit::WebDocument::operator=): + (WebKit::WebDocument::operator WTF::PassRefPtr<Document>): + (WebKit::WebDocument::frame): + (WebKit::WebDocument::isHTMLDocument): + (WebKit::WebDocument::baseURL): + (WebKit::WebDocument::body): + (WebKit::WebDocument::head): + (WebKit::WebDocument::all): + (WebKit::WebDocument::completeURL): + * src/WebElement.cpp: + (WebKit::WebElement::hasTagName): + (WebKit::WebElement::hasAttribute): + (WebKit::WebElement::getAttribute): + * src/WebEntities.cpp: Added. + (WebKit::populateMap): + (WebKit::): + (WebKit::WebEntities::WebEntities): + (WebKit::WebEntities::entityNameByCode): + (WebKit::WebEntities::convertEntitiesInString): + * src/WebEntities.h: Added. + * src/WebFrameImpl.cpp: + (WebKit::WebFrame::fromFrameOwnerElement): + (WebKit::WebFrameImpl::encoding): + (WebKit::WebFrameImpl::document): + (WebKit::WebFrameImpl::fromFrameOwnerElement): + * src/WebFrameImpl.h: + * src/WebNode.cpp: + (WebKit::WebNode::nodeType): + (WebKit::WebNode::nodeValue): + (WebKit::WebNode::document): + (WebKit::WebNode::firstChild): + (WebKit::WebNode::lastChild): + (WebKit::WebNode::previousSibling): + (WebKit::WebNode::nextSibling): + (WebKit::WebNode::hasChildNodes): + (WebKit::WebNode::childNodes): + (WebKit::WebNode::createMarkup): + (WebKit::WebNode::isTextNode): + (WebKit::WebNode::isElementNode): + * src/WebNodeCollection.cpp: Added. + (WebKit::WebNodeCollection::reset): + (WebKit::WebNodeCollection::assign): + (WebKit::WebNodeCollection::WebNodeCollection): + (WebKit::WebNodeCollection::length): + (WebKit::WebNodeCollection::nextItem): + (WebKit::WebNodeCollection::firstItem): + * src/WebNodeList.cpp: Added. + (WebKit::WebNodeList::reset): + (WebKit::WebNodeList::assign): + (WebKit::WebNodeList::WebNodeList): + (WebKit::WebNodeList::length): + (WebKit::WebNodeList::item): + * src/WebPageSerializer.cpp: Added. + (WebKit::WebPageSerializer::serialize): + (WebKit::WebPageSerializer::generateMetaCharsetDeclaration): + (WebKit::WebPageSerializer::generateMarkOfTheWebDeclaration): + (WebKit::WebPageSerializer::generateBaseTagDeclaration): + * src/WebPageSerializerImpl.cpp: Added. + (WebKit::WebPageSerializerImpl::SerializeDomParam::SerializeDomParam): + (WebKit::WebPageSerializerImpl::preActionBeforeSerializeOpenTag): + (WebKit::WebPageSerializerImpl::postActionAfterSerializeOpenTag): + (WebKit::WebPageSerializerImpl::preActionBeforeSerializeEndTag): + (WebKit::WebPageSerializerImpl::postActionAfterSerializeEndTag): + (WebKit::WebPageSerializerImpl::saveHTMLContentToBuffer): + (WebKit::WebPageSerializerImpl::openTagToString): + (WebKit::WebPageSerializerImpl::endTagToString): + (WebKit::WebPageSerializerImpl::buildContentForNode): + (WebKit::WebPageSerializerImpl::WebPageSerializerImpl): + (WebKit::WebPageSerializerImpl::collectTargetFrames): + (WebKit::WebPageSerializerImpl::serialize): + * src/WebPageSerializerImpl.h: Added. + * src/WebString.cpp: + (WebKit::WebString::WebString): + (WebKit::WebString::operator=): + * src/WebViewImpl.cpp: + +2009-12-17 Yury Semikhatsky <yurys@chromium.org> + + Reviewed by David Levin. + + Provide explicit implementation of 'non-template' WebVector<T>::operator= + + https://bugs.webkit.org/show_bug.cgi?id=32363 + + * public/WebVector.h: + +2009-12-16 Fumitoshi Ukai <ukai@chromium.org> + + Unreviewed, build fix. + + [Chromium] Add EditableTextRole to catch up with + http://trac.webkit.org/changeset/52233 + + * public/WebAccessibilityRole.h: + (WebKit::): Added WebAccessibilityRoleEditableText + * src/AssertMatchingEnums.cpp: Added matching compile assert. + +2009-12-15 Kenneth Russell <kbr@google.com> + + Reviewed by Darin Fisher. + + Don't allow default framebuffer to be mutated + https://bugs.webkit.org/show_bug.cgi?id=32391 + + * src/GraphicsContext3D.cpp: + (WebCore::GraphicsContext3DInternal::GraphicsContext3DInternal): + (WebCore::GraphicsContext3DInternal::reshape): + (WebCore::GraphicsContext3DInternal::beginPaint): + (WebCore::GraphicsContext3DInternal::bindFramebuffer): + (WebCore::GraphicsContext3D::bindFramebuffer): + +2009-12-15 Dimitri Glazkov <dglazkov@chromium.org> + + Unreviewed, build fix. + + [Chromium] Add TreeGridRole to catch up with + http://trac.webkit.org/changeset/52159. + + * public/WebAccessibilityRole.h: + (WebKit::): Added WebAccessibilityRoleTreeGrid. + * src/AssertMatchingEnums.cpp: Added matching compile assert. + +2009-12-15 Jian Li <jianli@chromium.org> + + Reviewed by Dmitry Titov. + + Bug 31090 - [Chromium] Add DownloadURL format to Chromium clipboard. + https://bugs.webkit.org/show_bug.cgi?id=31090 + + The proposal to whatwg can be found here: + http://lists.whatwg.org/htdig.cgi/whatwg-whatwg.org/2009-August/022118.html + + * public/WebDragData.h: + * src/WebDragData.cpp: + (WebKit::WebDragData::downloadURL): + (WebKit::WebDragData::setDownloadURL): + +2009-12-14 Evan Stade <estade@chromium.org> + + Reviewed by Darin Fisher. + + https://bugs.webkit.org/show_bug.cgi?id=32347 + Chromium: Context menu launched by menu key has funky behavior + + Make the context menu's position depend on the selection only when an + editable field has focus. Also, don't send multiple context menu events + for a single keypress. + + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::keyEvent): + (WebKit::WebViewImpl::sendContextMenuEvent): + +2009-12-13 Sam Weinig <sam@webkit.org> + + Reviewed by Dan Bernstein. + + Fix for https://bugs.webkit.org/show_bug.cgi?id=32499 + Add client based Geolocation provider + + Add first cut of a client based Geolocation provider. This is guarded by + ENABLE(CLIENT_BASED_GEOLOCATION) and is off by default for now. This adds a + GeolocationControllerClient interface that no-one currently implements, + but will in a subsequent patch. + + * src/WebViewImpl.cpp: + (WebKit::WebViewImpl::WebViewImpl): + +2009-12-13 Charles Reis <creis@chromium.org> + + Reviewed by Adam Barth. + + Refactor some security code out of V8 bindings + https://bugs.webkit.org/show_bug.cgi?id=32326 + + * src/WebBindings.cpp: + (WebKit::getDragDataImpl): + +2009-12-11 Nate Chapin <japhet@chromium.org> + + Reviewed by Darin Fisher. + + Expose shouldHideReferrer() in WebSecurityPolicy. + + https://bugs.webkit.org/show_bug.cgi?id=32398 + + * public/WebSecurityPolicy.h: Add shouldHideReferrer(). + * src/WebSecurityPolicy.cpp: + (WebKit:: WebSecurityPolicy::shouldHideReferrer): Added. + +2009-12-11 Avi Drissman <avi@chromium.org> + + Reviewed by Darin Fisher. + + Tickmarks in the scrollbar are not cleared for non-main frames + https://bugs.webkit.org/show_bug.cgi?id=32385 + + * src/WebFrameImpl.cpp: + (WebKit::WebFrameImpl::stopFinding): + +2009-12-11 Yury Semikhatsky <yurys@chromium.org> + + Reviewed by Pavel Feldman. + + Remove obsolete message handling methods from WebDevTools* interfaces + + https://bugs.webkit.org/show_bug.cgi?id=32320 + + * public/WebDevToolsAgent.h: + * public/WebDevToolsAgentClient.h: + * public/WebDevToolsFrontend.h: + * public/WebDevToolsFrontendClient.h: + +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 new file mode 100644 index 0000000..9c45b83 --- /dev/null +++ b/WebKit/chromium/DEPS @@ -0,0 +1,199 @@ +# +# 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. +# + +# This file is used by gclient to fetch the projects that the webkit +# chromium port depends on. + +vars = { + 'chromium_svn': 'http://src.chromium.org/svn/trunk/src', + 'chromium_deps_svn': 'http://src.chromium.org/svn/trunk/deps/third_party', + + # Dependencies' revisions to use: + 'chromium_rev': '38580', + 'google-url_rev': '121', + 'gtest_rev': '359', + 'gyp_rev': '781', + 'icu_rev': '37341', + 'openvcdiff_rev': '28', + 'ots_rev': '26', + 'skia_rev': '490', + 'v8_rev': '3781', + + # Windows: + 'cygwin_rev': '11984', + 'ffmpeg_ia32_rev': '34297', + 'pthreads-win32_rev': '26716', + 'python_24_rev': '22967', + 'nss_rev': '36871', +} + +deps = { + # build tools + 'build': + Var('chromium_svn')+'/build@'+Var('chromium_rev'), + 'tools/gyp': + 'http://gyp.googlecode.com/svn/trunk@'+Var('gyp_rev'), + + # Basic tools + 'base': + Var('chromium_svn')+'/base@'+Var('chromium_rev'), + + # skia dependencies + 'skia': + Var('chromium_svn')+'/skia@'+Var('chromium_rev'), + 'third_party/skia': + 'http://skia.googlecode.com/svn/trunk@'+Var('skia_rev'), + + # testing + 'testing': + Var('chromium_svn')+'/testing@'+Var('chromium_rev'), + 'testing/gtest': + 'http://googletest.googlecode.com/svn/trunk@'+Var('gtest_rev'), + + # v8 javascript engine + 'v8': + 'http://v8.googlecode.com/svn/trunk@'+Var('v8_rev'), + 'testing/gtest': + 'http://googletest.googlecode.com/svn/trunk@'+Var('gtest_rev'), + + # net dependencies + 'net': + Var('chromium_svn')+'/net@'+Var('chromium_rev'), + 'sdch': + Var('chromium_svn')+'/sdch@'+Var('chromium_rev'), + 'sdch/open-vcdiff': + 'http://open-vcdiff.googlecode.com/svn/trunk@'+Var('openvcdiff_rev'), + 'googleurl': + 'http://google-url.googlecode.com/svn/trunk@'+Var('google-url_rev'), + + # other third party + 'third_party/icu': + Var('chromium_deps_svn')+'/icu42@'+Var('icu_rev'), + + 'third_party/bzip2': + Var('chromium_svn')+'/third_party/bzip2@'+Var('chromium_rev'), + + 'third_party/libevent': + Var('chromium_svn')+'/third_party/libevent@'+Var('chromium_rev'), + + 'third_party/libjpeg': + Var('chromium_svn')+'/third_party/libjpeg@'+Var('chromium_rev'), + + 'third_party/libpng': + Var('chromium_svn')+'/third_party/libpng@'+Var('chromium_rev'), + + 'third_party/libxml': + Var('chromium_svn')+'/third_party/libxml@'+Var('chromium_rev'), + + 'third_party/libxslt': + Var('chromium_svn')+'/third_party/libxslt@'+Var('chromium_rev'), + + 'third_party/modp_b64': + Var('chromium_svn')+'/third_party/modp_b64@'+Var('chromium_rev'), + + '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'), + + 'third_party/zlib': + Var('chromium_svn')+'/third_party/zlib@'+Var('chromium_rev'), +} + +deps_os = { + 'win': { + 'third_party/cygwin': + Var('chromium_deps_svn')+'/cygwin@'+Var('cygwin_rev'), + + 'third_party/python_24': + Var('chromium_deps_svn')+'/python_24@'+Var('python_24_rev'), + + 'third_party/ffmpeg/binaries/chromium/win/ia32': + Var('chromium_deps_svn')+'/ffmpeg/binaries/win@'+Var('ffmpeg_ia32_rev'), + + 'third_party/pthreads-win32': + Var('chromium_deps_svn')+'/pthreads-win32@'+Var('pthreads-win32_rev'), + + # base.gypi depends on nss on Windows + 'third_party/nss': + Var('chromium_deps_svn')+'/nss@'+Var('nss_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 = [ + # Don't look for dependencies in the following folders: + 'base', + 'build', + 'googleurl', + 'net', + 'sdch', + 'skia', + 'testing', + 'third_party', + 'tools', + 'v8', + 'webkit', +] + +include_rules = [ + # Everybody can use some things. + '+base', + '+build', + '+ipc', + + # For now, we allow ICU to be included by specifying 'unicode/...', although + # this should probably change. + '+unicode', + '+testing', + + # Allow anybody to include files from the 'public' Skia directory in the + # webkit port. This is shared between the webkit port and Chromium. + '+webkit/port/platform/graphics/skia/public', +] + + +hooks = [ + { + # A change to any file in this directory should run the gyp generator. + 'pattern': '.', + 'action': ['python', 'gyp_webkit'], + }, +] 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..4b0ad2b --- /dev/null +++ b/WebKit/chromium/WebKit.gyp @@ -0,0 +1,477 @@ +# +# 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': { + 'webkit_target_type': 'static_library', + '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': '../../WebKit/chromium', + },{ + # WebKit is checked out in src/chromium/third_party/WebKit + 'chromium_src_dir': '../../../..', + }], + # We can't turn on warnings on Windows and Linux until we upstream the + # WebKit API. + ['OS=="mac"', { + 'chromium_code': 1, + }], + ], + }, + '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/linux/WebRenderTheme.h', + 'public/x11/WebScreenInfoFactory.h', + 'public/mac/WebInputEventFactory.h', + 'public/mac/WebScreenInfoFactory.h', + 'public/WebAccessibilityCache.h', + 'public/WebAccessibilityObject.h', + 'public/WebAccessibilityRole.h', + 'public/WebAnimationController.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/WebDocument.h', + 'public/WebDragData.h', + 'public/WebEditingAction.h', + 'public/WebElement.h', + 'public/WebEvent.h', + 'public/WebEventListener.h', + 'public/WebFileChooserCompletion.h', + 'public/WebFileChooserParams.h', + 'public/WebFileInfo.h', + 'public/WebFindOptions.h', + 'public/WebFrame.h', + 'public/WebFrameClient.h', + 'public/WebFontCache.h', + 'public/WebFormElement.h', + 'public/WebGlyphCache.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/WebMutationEvent.h', + 'public/WebNavigationType.h', + 'public/WebNode.h', + 'public/WebNodeCollection.h', + 'public/WebNodeList.h', + 'public/WebNonCopyable.h', + 'public/WebNotification.h', + 'public/WebNotificationPresenter.h', + 'public/WebNotificationPermissionCallback.h', + 'public/WebPageSerializer.h', + 'public/WebPageSerializerClient.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/APUAgentDelegate.h', + 'src/ApplicationCacheHost.cpp', + 'src/ApplicationCacheHostInternal.h', + 'src/AssertMatchingEnums.cpp', + 'src/AutocompletePopupMenuClient.cpp', + 'src/AutocompletePopupMenuClient.h', + 'src/AutoFillPopupMenuClient.cpp', + 'src/AutoFillPopupMenuClient.h', + 'src/BackForwardListClientImpl.cpp', + 'src/BackForwardListClientImpl.h', + 'src/BoundObject.cpp', + 'src/BoundObject.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/DebuggerAgent.h', + 'src/DebuggerAgentImpl.cpp', + 'src/DebuggerAgentImpl.h', + 'src/DebuggerAgentManager.cpp', + 'src/DebuggerAgentManager.h', + 'src/DevToolsRPC.h', + 'src/DevToolsRPCJS.h', + 'src/DOMUtilitiesPrivate.cpp', + 'src/DOMUtilitiesPrivate.h', + 'src/DragClientImpl.cpp', + 'src/DragClientImpl.h', + 'src/EditorClientImpl.cpp', + 'src/EditorClientImpl.h', + 'src/EventListenerWrapper.cpp', + 'src/EventListenerWrapper.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/linux/WebRenderTheme.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/ProfilerAgent.h', + 'src/ProfilerAgentImpl.cpp', + 'src/ProfilerAgentImpl.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/SuggestionsPopupMenuClient.cpp', + 'src/SuggestionsPopupMenuClient.h', + 'src/TemporaryGlue.h', + 'src/ToolsAgent.h', + 'src/WebAccessibilityCache.cpp', + 'src/WebAccessibilityCacheImpl.cpp', + 'src/WebAccessibilityCacheImpl.h', + 'src/WebAccessibilityObject.cpp', + 'src/WebAnimationControllerImpl.cpp', + 'src/WebAnimationControllerImpl.h', + '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/WebDevToolsAgentImpl.cpp', + 'src/WebDevToolsAgentImpl.h', + 'src/WebDevToolsFrontendImpl.cpp', + 'src/WebDevToolsFrontendImpl.h', + 'src/WebDocument.cpp', + 'src/WebDragData.cpp', + 'src/WebElement.cpp', + 'src/WebEntities.cpp', + 'src/WebEntities.h', + 'src/WebEvent.cpp', + 'src/WebEventListener.cpp', + 'src/WebEventListenerPrivate.cpp', + 'src/WebEventListenerPrivate.h', + 'src/WebFileChooserCompletionImpl.cpp', + 'src/WebFileChooserCompletionImpl.h', + 'src/WebFontCache.cpp', + 'src/WebFormElement.cpp', + 'src/WebFrameImpl.cpp', + 'src/WebFrameImpl.h', + 'src/WebGlyphCache.cpp', + '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/WebMutationEvent.cpp', + 'src/WebNode.cpp', + 'src/WebNodeCollection.cpp', + 'src/WebNodeList.cpp', + 'src/WebNotification.cpp', + 'src/WebPageSerializer.cpp', + 'src/WebPageSerializerImpl.cpp', + 'src/WebPageSerializerImpl.h', + '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', + ], + }, + }], + ], + }], + ], + }, + { + 'target_name': 'webkit_unit_tests', + 'type': 'executable', + 'msvs_guid': '7CEFE800-8403-418A-AD6A-2D52C6FC3EAD', + 'dependencies': [ + 'webkit', + '../../WebCore/WebCore.gyp/WebCore.gyp:webcore', + '<(chromium_src_dir)/testing/gtest.gyp:gtest', + '<(chromium_src_dir)/base/base.gyp:base', + '<(chromium_src_dir)/base/base.gyp:base_i18n', + ], + 'include_dirs': [ + 'public', + 'src', + ], + 'sources': [ + 'tests/KeyboardTest.cpp', + 'tests/KURLTest.cpp', + 'tests/RunAllTests.cpp', + ], + 'conditions': [ + ['OS=="win"', { + 'sources': [ + 'tests/TransparencyWinTest.cpp', + 'tests/UniscribeHelperTest.cpp', + ], + }], + ], + }, + ], # targets +} + +# Local Variables: +# tab-width:2 +# indent-tabs-mode:nil +# End: +# vim: set expandtab tabstop=2 shiftwidth=2: diff --git a/WebKit/chromium/WebKit.gypi b/WebKit/chromium/WebKit.gypi new file mode 100644 index 0000000..69b1479 --- /dev/null +++ b/WebKit/chromium/WebKit.gypi @@ -0,0 +1,67 @@ +# +# Copyright (C) 2010 Google Inc. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following disclaimer +# in the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Google Inc. nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +{ + 'variables': { + # List of DevTools source files, ordered by dependencies. It is used both + # for copying them to resource dir, and for generating 'devtools.html' file. + 'devtools_js_files': [ + 'src/js/InspectorControllerImpl.js', + 'src/js/DebuggerAgent.js', + 'src/js/ProfilerAgent.js', + 'src/js/ProfilerProcessor.js', + 'src/js/HeapProfilerPanel.js', + 'src/js/DevTools.js', + 'src/js/DevToolsHostStub.js', + 'src/js/Tests.js', + ], + 'devtools_css_files': [ + 'src/js/devTools.css', + ], + 'devtools_image_files': [ + 'src/js/Images/segmentChromium.png', + 'src/js/Images/segmentHoverChromium.png', + 'src/js/Images/segmentHoverEndChromium.png', + 'src/js/Images/segmentSelectedChromium.png', + 'src/js/Images/segmentSelectedEndChromium.png', + 'src/js/Images/statusbarBackgroundChromium.png', + 'src/js/Images/statusbarBottomBackgroundChromium.png', + 'src/js/Images/statusbarButtonsChromium.png', + 'src/js/Images/statusbarMenuButtonChromium.png', + 'src/js/Images/statusbarMenuButtonSelectedChromium.png', + ], + }, +} + +# 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 new file mode 100644 index 0000000..6091b8f --- /dev/null +++ b/WebKit/chromium/features.gypi @@ -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. +# + +{ + # The following defines turn webkit features on and off. + 'variables': { + 'variables': { + # We have to nest variables inside variables as a hack for variables + # override. + + # WARNING: build/features_override.gypi which is included in a full + # chromium build, overrides this list with its own values. See + # features_override.gypi inline documentation for more details. + 'feature_defines%': [ + 'ENABLE_3D_CANVAS=0', + 'ENABLE_CHANNEL_MESSAGING=1', + 'ENABLE_DATABASE=1', + 'ENABLE_DATAGRID=0', + 'ENABLE_OFFLINE_WEB_APPLICATIONS=1', + 'ENABLE_DASHBOARD_SUPPORT=0', + 'ENABLE_DOM_STORAGE=1', + 'ENABLE_GEOLOCATION=1', + 'ENABLE_JAVASCRIPT_DEBUGGER=1', + 'ENABLE_JSC_MULTIPLE_THREADS=0', + 'ENABLE_ICONDATABASE=0', + 'ENABLE_INDEXED_DATABASE=1', + 'ENABLE_NOTIFICATIONS=1', + 'ENABLE_OPENTYPE_SANITIZER=1', + 'ENABLE_ORIENTATION_EVENTS=0', + 'ENABLE_RUBY=1', + 'ENABLE_XHTMLMP=0', + 'ENABLE_XSLT=1', + 'ENABLE_XPATH=1', + 'ENABLE_SHARED_WORKERS=1', + 'ENABLE_SVG=1', + 'ENABLE_SVG_ANIMATION=1', + 'ENABLE_SVG_AS_IMAGE=1', + 'ENABLE_SVG_USE=1', + 'ENABLE_SVG_FOREIGN_OBJECT=1', + 'ENABLE_SVG_FONTS=1', + 'ENABLE_VIDEO=1', + 'ENABLE_WEB_SOCKETS=1', + 'ENABLE_WORKERS=1', + ], + }, + 'feature_defines%': '<(feature_defines)', + }, +} diff --git a/WebKit/chromium/gyp_webkit b/WebKit/chromium/gyp_webkit new file mode 100644 index 0000000..ef18239 --- /dev/null +++ b/WebKit/chromium/gyp_webkit @@ -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. +# + +# This file is used by gclient execute gyp with the proper command +# line arguments. + +import glob +import os +import platform +import shlex +import sys + +script_dir = os.path.dirname(__file__) + +sys.path.append(os.path.join(script_dir, 'tools', 'gyp', 'pylib')) +import gyp + +def additional_include_files(args=[]): + """ + Returns a list of additional (.gypi) files to include, without + duplicating ones that are already specified on the command line. + """ + # Determine the include files specified on the command line. + # This doesn't cover all the different option formats you can use, + # but it's mainly intended to avoid duplicating flags on the automatic + # makefile regeneration which only uses this format. + specified_includes = set() + for arg in args: + if arg.startswith('-I') and len(arg) > 2: + specified_includes.add(os.path.realpath(arg[2:])) + + result = [] + def AddInclude(path): + if os.path.realpath(path) not in specified_includes: + result.append(path) + + # Always include common.gypi + AddInclude(os.path.join(script_dir, 'build', 'common.gypi')) + + # Optionally add supplemental .gypi files if present. + supplements = glob.glob(os.path.join(script_dir, '*', 'supplement.gypi')) + for supplement in supplements: + AddInclude(supplement) + + return result + +if __name__ == '__main__': + + args = sys.argv[1:] + + # 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. + '-Dinside_chromium_build=0', + '-Dv8_use_snapshot=false', + '-Dmsvs_use_common_release=0', + + # gyp hack: otherwise gyp assumes its in chromium's src/ dir. + '--depth=./', + + # gyp file to execute. + 'WebKit.gyp']) + + print 'Updating webkit projects from gyp files...' + sys.stdout.flush() + + # Off we go... + sys.exit(gyp.main(args)) 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..f46c0d8 --- /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 isMultiSelectable() 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..ec041e0 --- /dev/null +++ b/WebKit/chromium/public/WebAccessibilityRole.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 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, + WebAccessibilityRoleTreeGrid, + WebAccessibilityRoleTreeItemRole, + WebAccessibilityRoleDirectory, + WebAccessibilityRoleEditableText, + + WebAccessibilityRoleListItem, + WebAccessibilityRoleMenuListPopup, + WebAccessibilityRoleMenuListOption, + + 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/WebAnimationController.h b/WebKit/chromium/public/WebAnimationController.h new file mode 100644 index 0000000..d727d70 --- /dev/null +++ b/WebKit/chromium/public/WebAnimationController.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 WebAnimationController_h +#define WebAnimationController_h + +#include "WebCommon.h" + +namespace WebKit { + +class WebElement; +class WebString; +class WebURL; + +// WebAnimationController can be used to control animations in a frame. It is +// owned by a WebFrame and its life span is bound to that WebFrame. +class WebAnimationController { +public: + WEBKIT_API virtual bool pauseAnimationAtTime(WebElement&, + const WebString& animationName, + double time) = 0; + WEBKIT_API virtual bool pauseTransitionAtTime(WebElement&, + const WebString& propertyName, + double time) = 0; + + WEBKIT_API virtual unsigned numberOfActiveAnimations() const = 0; +protected: + ~WebAnimationController() { } +}; + +} // 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..5d67046 --- /dev/null +++ b/WebKit/chromium/public/WebContextMenuData.h @@ -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. + */ + +#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 CheckableMenuItemFlags { + CheckableMenuItemDisabled = 0x0, + CheckableMenuItemEnabled = 0x1, + CheckableMenuItemChecked = 0x2, + }; + + // Writing direction menu items - values are unions of + // CheckableMenuItemFlags. + // Currently only used on OS X. + int writingDirectionDefault; + int writingDirectionLeftToRight; + int writingDirectionRightToLeft; + + 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..1aa7a98 --- /dev/null +++ b/WebKit/chromium/public/WebDataSource.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 WebDataSource_h +#define WebDataSource_h + +#include "WebCommon.h" +#include "WebNavigationType.h" + +namespace WebKit { + +class WebApplicationCacheHost; +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; + + // The application cache host associated with this datasource. + virtual WebApplicationCacheHost* applicationCacheHost() = 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..108201d --- /dev/null +++ b/WebKit/chromium/public/WebDatabase.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 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); + WEBKIT_API static void closeDatabaseImmediately( + const WebString& originIdentifier, const WebString& databaseName); + +#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..e3b5186 --- /dev/null +++ b/WebKit/chromium/public/WebDevToolsAgent.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 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; + + 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(); + + 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..d78a6f1 --- /dev/null +++ b/WebKit/chromium/public/WebDevToolsAgentClient.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 WebDevToolsAgentClient_h +#define WebDevToolsAgentClient_h + +#include "WebCString.h" +#include "WebCommon.h" + +namespace WebKit { +class WebString; +struct WebDevToolsMessageData; + +class WebDevToolsAgentClient { +public: + 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) { } + + WEBKIT_API static void sendMessageToFrontendOnIOThread(const WebDevToolsMessageData&); + + virtual WebCString injectedScriptSource() { return WebCString(); } + virtual WebCString injectedScriptDispatcherSource() { return WebCString(); } + +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..d95f35a --- /dev/null +++ b/WebKit/chromium/public/WebDevToolsFrontend.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 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 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..6200709 --- /dev/null +++ b/WebKit/chromium/public/WebDevToolsFrontendClient.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 WebDevToolsFrontendClient_h +#define WebDevToolsFrontendClient_h + +namespace WebKit { + +class WebString; +struct WebDevToolsMessageData; + +class WebDevToolsFrontendClient { +public: + WebDevToolsFrontendClient() {} + + 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/WebDocument.h b/WebKit/chromium/public/WebDocument.h new file mode 100644 index 0000000..e158c41 --- /dev/null +++ b/WebKit/chromium/public/WebDocument.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 WebDocument_h +#define WebDocument_h + +#include "WebNode.h" + +#if WEBKIT_IMPLEMENTATION +namespace WebCore { class Document; } +namespace WTF { template <typename T> class PassRefPtr; } +#endif + +namespace WebKit { +class WebElement; +class WebFrame; +class WebNodeCollection; +class WebString; +class WebURL; + +// Provides readonly access to some properties of a DOM document. +class WebDocument : public WebNode { +public: + WebDocument() { } + WebDocument(const WebDocument& e) : WebNode(e) { } + + WebDocument& operator=(const WebDocument& e) + { + WebNode::assign(e); + return *this; + } + void assign(const WebDocument& e) { WebNode::assign(e); } + + // Returns the frame the document belongs to or 0 if the document is frameless. + WEBKIT_API WebFrame* frame() const; + WEBKIT_API bool isHTMLDocument() const; + WEBKIT_API WebURL baseURL() const; + WEBKIT_API WebElement documentElement() const; + WEBKIT_API WebElement body() const; + WEBKIT_API WebElement head(); + WEBKIT_API WebNodeCollection all(); + WEBKIT_API WebURL completeURL(const WebString&) const; + WEBKIT_API WebElement getElementById(const WebString& id) const; + WEBKIT_API WebString applicationID() const; + +#if WEBKIT_IMPLEMENTATION + WebDocument(const WTF::PassRefPtr<WebCore::Document>&); + WebDocument& operator=(const WTF::PassRefPtr<WebCore::Document>&); + operator WTF::PassRefPtr<WebCore::Document>() const; +#endif +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebDragData.h b/WebKit/chromium/public/WebDragData.h new file mode 100644 index 0000000..0b861c8 --- /dev/null +++ b/WebKit/chromium/public/WebDragData.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 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 WebURL downloadURL() const; + WEBKIT_API void setDownloadURL(const WebURL&); + WEBKIT_API WebString downloadMetadata() const; + WEBKIT_API void setDownloadMetadata(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..20f6c9a --- /dev/null +++ b/WebKit/chromium/public/WebElement.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 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 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; } + void assign(const WebElement& e) { WebNode::assign(e); } + + WEBKIT_API WebString tagName() const; + WEBKIT_API bool hasTagName(const WebString&) const; + WEBKIT_API bool hasAttribute(const WebString&) const; + WEBKIT_API WebString getAttribute(const WebString&) const; + WEBKIT_API bool setAttribute(const WebString& name, const WebString& value); + WEBKIT_API WebString innerText() const; + +#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/WebEvent.h b/WebKit/chromium/public/WebEvent.h new file mode 100644 index 0000000..b0964d1 --- /dev/null +++ b/WebKit/chromium/public/WebEvent.h @@ -0,0 +1,116 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebEvent_h +#define WebEvent_h + +#include "WebCommon.h" +#include "WebNode.h" +#include "WebString.h" + +namespace WebCore { class Event; } +#if WEBKIT_IMPLEMENTATION +namespace WTF { template <typename T> class PassRefPtr; } +#endif + +namespace WebKit { + +class WebEvent { +public: + enum PhaseType { + CapturingPhase = 1, + AtTarget = 2, + BubblingPhase = 3 + }; + + WebEvent() : m_private(0) { } + WebEvent(const WebEvent& e) : m_private(0) { assign(e); } + WebEvent& operator=(const WebEvent& e) + { + assign(e); + return *this; + } + + WEBKIT_API void reset(); + WEBKIT_API void assign(const WebEvent&); + + bool isNull() const { return !m_private; } + + WEBKIT_API WebString type() const; + WEBKIT_API WebNode target() const; + WEBKIT_API WebNode currentTarget() const; + + WEBKIT_API PhaseType eventPhase() const; + WEBKIT_API bool bubbles() const; + WEBKIT_API bool cancelable() const; + + WEBKIT_API bool isUIEvent() const; + WEBKIT_API bool isMouseEvent() const; + WEBKIT_API bool isMutationEvent() const; + WEBKIT_API bool isKeyboardEvent() const; + WEBKIT_API bool isTextEvent() const; + WEBKIT_API bool isCompositionEvent() const; + WEBKIT_API bool isDragEvent() const; + WEBKIT_API bool isClipboardEvent() const; + WEBKIT_API bool isMessageEvent() const; + WEBKIT_API bool isWheelEvent() const; + WEBKIT_API bool isBeforeTextInsertedEvent() const; + WEBKIT_API bool isOverflowEvent() const; + WEBKIT_API bool isPageTransitionEvent() const; + WEBKIT_API bool isPopStateEvent() const; + WEBKIT_API bool isProgressEvent() const; + WEBKIT_API bool isXMLHttpRequestProgressEvent() const; + WEBKIT_API bool isWebKitAnimationEvent() const; + WEBKIT_API bool isWebKitTransitionEvent() const; + WEBKIT_API bool isBeforeLoadEvent() const; + +#if WEBKIT_IMPLEMENTATION + WebEvent(const WTF::PassRefPtr<WebCore::Event>&); +#endif + +protected: + typedef WebCore::Event WebEventPrivate; + void assign(WebEventPrivate*); + WebEventPrivate* 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/WebEventListener.h b/WebKit/chromium/public/WebEventListener.h new file mode 100644 index 0000000..52de1cd --- /dev/null +++ b/WebKit/chromium/public/WebEventListener.h @@ -0,0 +1,66 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebEventListener_h +#define WebEventListener_h + +#if WEBKIT_IMPLEMENTATION +namespace WebCore { class Node; } +#endif + +namespace WebKit { + +class EventListenerWrapper; +class WebEvent; +class WebEventListenerPrivate; +class WebNode; +class WebString; + +class WebEventListener { +public: + WebEventListener(); + virtual ~WebEventListener(); + + // Called when an event is received. + virtual void handleEvent(const WebEvent&) = 0; + +#if WEBKIT_IMPLEMENTATION + void notifyEventListenerDeleted(EventListenerWrapper*); + EventListenerWrapper* createEventListenerWrapper(const WebString& eventType, bool useCapture, WebCore::Node* node); + EventListenerWrapper* getEventListenerWrapper(const WebString& eventType, bool useCapture, WebCore::Node* node); +#endif + +private: + WebEventListenerPrivate* m_private; +}; + +} // 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/WebFileChooserParams.h b/WebKit/chromium/public/WebFileChooserParams.h new file mode 100644 index 0000000..6359f14 --- /dev/null +++ b/WebKit/chromium/public/WebFileChooserParams.h @@ -0,0 +1,64 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebFileChooserParams_h +#define WebFileChooserParams_h + +#include "WebFileChooserCompletion.h" +#include "WebString.h" +#include "WebVector.h" + +namespace WebKit { + +struct WebFileChooserParams { + // If |multiSelect| is true, the dialog allow to select multiple files. + bool multiSelect; + // |title| is a title of a file chooser dialog. It can be an empty string. + WebString title; + // |initialValue| is a filename which the dialog should select by default. + // It can be an empty string. + WebString initialValue; + // |acceptTypes| has a comma-separated MIME types such as "audio/*,text/plain". + // The dialog may restrict selectable files to the specified MIME types. + // This value comes from an 'accept' attribute value of an INPUT element. + // So it might be a wrong formatted string. + WebString acceptTypes; + // |selectedFiles| has filenames which a file upload control already select. + // A WebViewClient implementation may ask a user to select + // - removing a file from the selected files, + // - appending other files, or + // - replacing with other files + // before opening a file chooser dialog. + WebVector<WebString> selectedFiles; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebFileInfo.h b/WebKit/chromium/public/WebFileInfo.h new file mode 100644 index 0000000..4590a30 --- /dev/null +++ b/WebKit/chromium/public/WebFileInfo.h @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebFileInfo_h +#define WebFileInfo_h + +namespace WebKit { + +struct WebFileInfo { + // The last modification time of the file, in seconds. + // The value 0.0 means that the time is not set. + double modificationTime; + + WebFileInfo() : modificationTime(0.0) { } +}; + +} // 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..b07bff9 --- /dev/null +++ b/WebKit/chromium/public/WebFormElement.h @@ -0,0 +1,78 @@ +/* + * 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) { } + + WebFormElement& 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..a56e6cb --- /dev/null +++ b/WebKit/chromium/public/WebFrame.h @@ -0,0 +1,499 @@ +/* + * 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 WebAnimationController; +class WebData; +class WebDataSource; +class WebDocument; +class WebElement; +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: + // Returns the number of live WebFrame objects, used for leak checking. + WEBKIT_API static int instanceCount(); + + // 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(); + + // Returns the frame inside a given frame or iframe element. Returns 0 if + // the given element is not a frame, iframe or if the frame is empty. + WEBKIT_API static WebFrame* fromFrameOwnerElement(const WebElement&); + + + // Basic properties --------------------------------------------------- + + // The name of this frame. + virtual WebString name() const = 0; + virtual void clearName() = 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; + + // Return the frame's encoding. + virtual WebString encoding() 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 WebDocument document() const = 0; + + virtual void forms(WebVector<WebFormElement>&) const = 0; + + virtual WebAnimationController* animationController() = 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 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; + + // Expands the selection to a word around the caret and returns + // true. Does nothing and returns false if there is no caret or + // there is ranged selection. + virtual bool selectWordAroundCaret() = 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. + // Deprecated. Use document().completeURL() instead. + 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; + + // Returns a text representation of the render tree. This method is used + // to support layout tests. + virtual WebString renderTreeAsText() const = 0; + + // Returns the counter value for the specified element. This method is + // used to support layout tests. + virtual WebString counterValueForElementById(const WebString& id) const = 0; + + + // Returns the number of page where the specified element will be put. + // This method is used to support layout tests. + virtual int pageNumberForElementById(const WebString& id, + float pageWidthInPixels, + float pageHeightInPixels) 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..4078151 --- /dev/null +++ b/WebKit/chromium/public/WebFrameClient.h @@ -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. + */ + +#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*) { } + + // Controls whether plugins are allowed for this frame. + virtual bool allowPlugins(WebFrame*, bool enabledPerSettings) { return enabledPerSettings; } + + // Controls whether images are allowed for this frame. + virtual bool allowImages(WebFrame*, bool enabledPerSettings) { return enabledPerSettings; } + + + // 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/WebGlyphCache.h b/WebKit/chromium/public/WebGlyphCache.h new file mode 100644 index 0000000..661767d --- /dev/null +++ b/WebKit/chromium/public/WebGlyphCache.h @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebGlyphCache_h +#define WebGlyphCache_h + +#include "WebCommon.h" + +namespace WebKit { + +// An interface to query WebKit's glyph cache (which maps unicode characters to +// glyphs in particular fonts). +class WebGlyphCache { +public: + // Returns the number of pages in the glyph cache. + WEBKIT_API static size_t pageCount(); + +private: + WebGlyphCache(); // Not intended to be instanced. +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebHTTPBody.h b/WebKit/chromium/public/WebHTTPBody.h new file mode 100644 index 0000000..fcc44ff --- /dev/null +++ b/WebKit/chromium/public/WebHTTPBody.h @@ -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. + */ + +#ifndef WebHTTPBody_h +#define WebHTTPBody_h + +#include "WebData.h" +#include "WebFileInfo.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; + long long fileStart; + long long fileLength; // -1 means to the end of the file. + WebFileInfo fileInfo; + }; + + ~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&); // FIXME: to be removed. + // Passing -1 to fileLength means to the end of the file. + WEBKIT_API void appendFile(const WebString&, long long fileStart, long long fileLength, const WebFileInfo&); + + // 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..e248a61 --- /dev/null +++ b/WebKit/chromium/public/WebHistoryItem.h @@ -0,0 +1,135 @@ +/* + * 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 long long documentSequenceNumber() const; + WEBKIT_API void setDocumentSequenceNumber(long long); + + 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..59643d1 --- /dev/null +++ b/WebKit/chromium/public/WebInputElement.h @@ -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. + */ + +#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 autoComplete() const; + WEBKIT_API bool isEnabledFormControl() const; + WEBKIT_API InputType inputType() const; + WEBKIT_API WebString formControlType() const; + WEBKIT_API bool isActivatedSubmit() 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..732cac6 --- /dev/null +++ b/WebKit/chromium/public/WebKit.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 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(); + +// Enables the named log channel. See WebCore/platform/Logging.h for details. +WEBKIT_API void enableLogChannel(const char*); + +// 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..fbaa218 --- /dev/null +++ b/WebKit/chromium/public/WebKitClient.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 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; +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. + // THIS IS DEPRECATED. WebViewClient::getSessionStorageNamespace() is the new way to access this. + 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& firstPartyForCookies, const WebString& cookies) { } + virtual WebString cookies(const WebURL& url, const WebURL& firstPartyForCookies) { return WebString(); } + virtual bool rawCookies(const WebURL& url, const WebURL& firstPartyForCookies, WebVector<WebCookie>*) { return false; } + virtual void deleteCookie(const WebURL& url, const WebString& cookieName) { } + virtual bool cookiesEnabled(const WebURL& url, const WebURL& firstPartyForCookies) { return true; } + + // 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..47ce64e --- /dev/null +++ b/WebKit/chromium/public/WebMediaPlayerClient.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 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(float) = 0; + virtual void muteChanged(bool) = 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/WebMutationEvent.h b/WebKit/chromium/public/WebMutationEvent.h new file mode 100644 index 0000000..75eb9c4 --- /dev/null +++ b/WebKit/chromium/public/WebMutationEvent.h @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#ifndef WebMutationEvent_h +#define WebMutationEvent_h + +#include "WebEvent.h" + +#if WEBKIT_IMPLEMENTATION +namespace WebCore { class Event; } +#endif + +namespace WebKit { + +class WebMutationEvent : public WebEvent { +public: + enum AttrChangeType { + Modification = 1, + Addition = 2, + Removal = 3 + }; + + WEBKIT_API WebNode relatedNode() const; + WEBKIT_API WebString prevValue() const; + WEBKIT_API WebString newValue() const; + WEBKIT_API WebString attrName() const; + WEBKIT_API AttrChangeType attrChange() const; +}; + +} // 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..4d2a0e9 --- /dev/null +++ b/WebKit/chromium/public/WebNode.h @@ -0,0 +1,140 @@ +/* + * 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 WebDocument; +class WebEventListener; +class WebEventListenerPrivate; +class WebFrame; +class WebNodeList; + +// Provides 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 + + enum NodeType { + ElementNode = 1, + AttributeNode, + TextNode, + CDataSectionNode, + EntityReferenceNode, + EntityNode, + ProcessingInstructionsNode, + CommentNode, + DocumentNode, + DocumentTypeNode, + DocumentFragmentNode, + NotationNode, + XPathNamespaceNode + }; + WEBKIT_API NodeType nodeType() const; + WEBKIT_API WebNode parentNode() const; + WEBKIT_API WebString nodeName() const; + WEBKIT_API WebString nodeValue() const; + WEBKIT_API bool setNodeValue(const WebString&); + // Deprecated. Use document().frame() instead. + WEBKIT_API WebFrame* frame() const; + WEBKIT_API WebDocument document() const; + WEBKIT_API WebNode firstChild() const; + WEBKIT_API WebNode lastChild() const; + WEBKIT_API WebNode previousSibling() const; + WEBKIT_API WebNode nextSibling() const; + WEBKIT_API bool hasChildNodes() const; + WEBKIT_API WebNodeList childNodes(); + WEBKIT_API WebString createMarkup() const; + WEBKIT_API bool isTextNode() const; + WEBKIT_API bool isElementNode() const; + WEBKIT_API void addEventListener(const WebString& eventType, WebEventListener* listener, bool useCapture); + WEBKIT_API void removeEventListener(const WebString& eventType, WebEventListener* listener, bool useCapture); + + template<typename T> T toElement() + { + T res; + res.WebNode::assign(*this); + return res; + } + + template<typename T> const T toConstElement() const + { + T res; + res.WebNode::assign(*this); + 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/WebNodeCollection.h b/WebKit/chromium/public/WebNodeCollection.h new file mode 100644 index 0000000..fee4f44 --- /dev/null +++ b/WebKit/chromium/public/WebNodeCollection.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 WebNodeCollection_h +#define WebNodeCollection_h + +#include "WebCommon.h" + +namespace WebCore { class HTMLCollection; } +#if WEBKIT_IMPLEMENTATION +namespace WTF { template <typename T> class PassRefPtr; } +#endif + +namespace WebKit { +class WebNode; + +// Provides readonly access to some properties of a DOM node. +class WebNodeCollection { +public: + ~WebNodeCollection() { reset(); } + + WebNodeCollection() : m_private(0) { } + WebNodeCollection(const WebNodeCollection& n) : m_private(0) { assign(n); } + WebNodeCollection& operator=(const WebNodeCollection& n) + { + assign(n); + return *this; + } + + WEBKIT_API void reset(); + WEBKIT_API void assign(const WebNodeCollection&); + + WEBKIT_API unsigned length() const; + WEBKIT_API WebNode nextItem() const; + WEBKIT_API WebNode firstItem() const; + +#if WEBKIT_IMPLEMENTATION + WebNodeCollection(const WTF::PassRefPtr<WebCore::HTMLCollection>&); +#endif + +private: + void assign(WebCore::HTMLCollection*); + WebCore::HTMLCollection* m_private; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebNodeList.h b/WebKit/chromium/public/WebNodeList.h new file mode 100644 index 0000000..23efab0 --- /dev/null +++ b/WebKit/chromium/public/WebNodeList.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 WebNodeList_h +#define WebNodeList_h + +#include "WebCommon.h" + +namespace WebCore { class NodeList; } +#if WEBKIT_IMPLEMENTATION +namespace WTF { template <typename T> class PassRefPtr; } +#endif + +namespace WebKit { +class WebNode; + +// Provides readonly access to some properties of a DOM node. +class WebNodeList { +public: + ~WebNodeList() { reset(); } + + WebNodeList() : m_private(0) { } + WebNodeList(const WebNodeList& n) : m_private(0) { assign(n); } + WebNodeList& operator=(const WebNodeList& n) + { + assign(n); + return *this; + } + + WEBKIT_API void reset(); + WEBKIT_API void assign(const WebNodeList&); + + WEBKIT_API unsigned length() const; + WEBKIT_API WebNode item(size_t) const; + +#if WEBKIT_IMPLEMENTATION + WebNodeList(const WTF::PassRefPtr<WebCore::NodeList>&); +#endif + +private: + void assign(WebCore::NodeList*); + WebCore::NodeList* 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..a3764aa --- /dev/null +++ b/WebKit/chromium/public/WebNotificationPresenter.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 WebNotificationPresenter_h +#define WebNotificationPresenter_h + +#include "WebString.h" + +namespace WebKit { + +class WebDocument; +class WebNotification; +class WebNotificationPermissionCallback; +class WebURL; + +// 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 for the given URL. If the URL is being displayed in a document + // (as opposed to a worker or other ScriptExecutionContext), |document| will also be provided. + virtual Permission checkPermission(const WebURL& url, WebDocument* document) = 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/WebPageSerializer.h b/WebKit/chromium/public/WebPageSerializer.h new file mode 100644 index 0000000..94f7994 --- /dev/null +++ b/WebKit/chromium/public/WebPageSerializer.h @@ -0,0 +1,85 @@ +/* + * 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 WebPageSerializer_h +#define WebPageSerializer_h + +#include "WebCommon.h" + +namespace WebKit { +class WebFrame; +class WebPageSerializerClient; +class WebString; +class WebURL; +template <typename T> class WebVector; + +// Get html data by serializing all frames of current page with lists +// which contain all resource links that have local copy. +class WebPageSerializer { +public: + // This function will find out all frames and serialize them to HTML data. + // We have a data buffer to temporary saving generated html data. We will + // sequentially call WebPageSeriazlierClient once the data buffer is full. + // + // Return false means no available frame has been serialized, otherwise + // return true. + // + // The parameter frame specifies which frame need to be serialized. + // The parameter recursive specifies whether we need to + // serialize all sub frames of the specified frame or not. + // The parameter client specifies the pointer of interface + // WebPageSerializerClient providing a sink interface to receive the + // individual chunks of data to be saved. + // The parameter links contain original URLs of all saved links. + // The parameter localPaths contain corresponding local file paths of all + // saved links, which matched with vector:links one by one. + // The parameter localDirectoryName is relative path of directory which + // contain all saved auxiliary files included all sub frames and resources. + WEBKIT_API static bool serialize(WebFrame* frame, + bool recursive, + WebPageSerializerClient* client, + const WebVector<WebURL>& links, + const WebVector<WebString>& localPaths, + const WebString& localDirectoryName); + + // FIXME: The following are here for unit testing purposes. Consider + // changing the unit tests instead. + + // Generate the META for charset declaration. + WEBKIT_API static WebString generateMetaCharsetDeclaration(const WebString& charset); + // Generate the MOTW declaration. + WEBKIT_API static WebString generateMarkOfTheWebDeclaration(const WebURL& url); + // Generate the default base tag declaration. + WEBKIT_API static WebString generateBaseTagDeclaration(const WebString& baseTarget); +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/public/WebPageSerializerClient.h b/WebKit/chromium/public/WebPageSerializerClient.h new file mode 100644 index 0000000..c30ddbc --- /dev/null +++ b/WebKit/chromium/public/WebPageSerializerClient.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 WebPageSerializerClient_h +#define WebPageSerializerClient_h + +namespace WebKit { +class WebCString; +class WebURL; + +// This class is used for providing sink interface that can be used to receive +// the individual chunks of data to be saved. +class WebPageSerializerClient { +public: + // This enum indicates This sink interface can receive the individual chunks + // of serialized data to be saved, so we use values of following enum + // definition to indicate the serialization status of serializing all html + // content. If current frame is not complete serialized, call + // didSerializeDataForFrame with URL of current frame, data, data length and + // flag CurrentFrameIsNotFinished. + // If current frame is complete serialized, call didSerializeDataForFrame + // with URL of current frame, data, data length and flag + // CurrentFrameIsFinished. + // If all frames of page are complete serialized, call + // didSerializeDataForFrame with empty URL, empty data, 0 and flag + // AllFramesAreFinished. + enum PageSerializationStatus { + CurrentFrameIsNotFinished, + CurrentFrameIsFinished, + AllFramesAreFinished, + }; + + // Receive the individual chunks of serialized and encoded data to be saved. + // The parameter frameURL specifies what frame the data belongs. The + // parameter data contains the available data for saving. The parameter + // status indicates the status of data serialization. + virtual void didSerializeDataForFrame(const WebURL& frameURL, + const WebCString& data, + PageSerializationStatus status) = 0; + WebPageSerializerClient() { } + +protected: + virtual ~WebPageSerializerClient() { } +}; + +} // 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..04f88c9 --- /dev/null +++ b/WebKit/chromium/public/WebRuntimeFeatures.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 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(); + + WEBKIT_API static void enableGeolocation(bool); + WEBKIT_API static bool isGeolocationEnabled(); + + WEBKIT_API static void enableIndexedDatabase(bool); + WEBKIT_API static bool isIndexedDatabaseEnabled(); + +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..1285b10 --- /dev/null +++ b/WebKit/chromium/public/WebSecurityOrigin.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 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; + } + + // FIXME: This should return a WebSecurityOrigin, not a pointer to one. + WEBKIT_API static WebSecurityOrigin* createFromDatabaseIdentifier(const WebString& databaseIdentifier); + WEBKIT_API static WebSecurityOrigin createFromString(const WebString&); + + 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..8e1ee52 --- /dev/null +++ b/WebKit/chromium/public/WebSecurityPolicy.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 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(); + + // Returns whether the url should be allowed to see the referrer + // based on their respective protocols. + WEBKIT_API static bool shouldHideReferrer(const WebURL& url, const WebString& referrer); + +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..d75ccde --- /dev/null +++ b/WebKit/chromium/public/WebSettings.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 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 setImagesEnabled(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..5e2c11c --- /dev/null +++ b/WebKit/chromium/public/WebStorageArea.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 WebStorageArea_h +#define WebStorageArea_h + +#include "WebCommon.h" +#include "WebString.h" + +namespace WebKit { + +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() { } + + enum Result { + ResultOK = 0, + ResultBlockedByQuota, + ResultBlockedByPolicy + }; + + // 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. Result will either be ResultOK + // or some particular error. The value is NOT set when there's an error. url is the + // url that should be used if a storage event fires. + virtual void setItem(const WebString& key, const WebString& newValue, const WebURL& url, Result& result, WebString& oldValue) + { + bool quotaException = false; + setItem(key, newValue, url, quotaException, oldValue); + result = quotaException ? ResultBlockedByQuota : ResultOK; + } + // FIXME: Remove soon (once Chrome has rolled past this revision). + virtual void setItem(const WebString& key, const WebString& newValue, const WebURL& url, bool& quotaException, WebString& oldValue) + { + Result result; + setItem(key, newValue, url, result, oldValue); + quotaException = result != ResultOK; + } + + // 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, WebString& oldValue) = 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, bool& somethingCleared) = 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..d2cf9ea --- /dev/null +++ b/WebKit/chromium/public/WebString.h @@ -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. + */ + +#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 bool equals(const WebString& s) const; + + 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); + + template <int N> WebString(const char (&data)[N]) + : m_private(0) + { + assign(fromUTF8(data, N - 1)); + } + + template <int N> WebString& operator=(const char (&data)[N]) + { + assign(fromUTF8(data, N - 1)); + return *this; + } + +#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; +}; + +inline bool operator==(const WebString& a, const WebString& b) +{ + return a.equals(b); +} + +inline bool operator!=(const WebString& a, const WebString& b) +{ + return !(a == b); +} + +} // 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..1dac069 --- /dev/null +++ b/WebKit/chromium/public/WebURLResponse.h @@ -0,0 +1,135 @@ +/* + * 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 + + // Flag whether this request was loaded via the SPDY protocol or not. + // SPDY is an experimental web protocol, see http://dev.chromium.org/spdy + WEBKIT_API bool wasFetchedViaSPDY() const; + WEBKIT_API void setWasFetchedViaSPDY(bool); + +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..0520895 --- /dev/null +++ b/WebKit/chromium/public/WebVector.h @@ -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. + */ + +#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()); + } + + WebVector& operator=(const WebVector& other) + { + if (this != &other) + assign(other); + return *this; + } + + 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..99125d4 --- /dev/null +++ b/WebKit/chromium/public/WebView.h @@ -0,0 +1,301 @@ +/* + * 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 / Autocomplete --------------------------------------------- + + // DEPRECATED: WebView::applyAutocompleteSuggestions is the new way to + // access this. + virtual void applyAutofillSuggestions( + const WebNode&, + const WebVector<WebString>& suggestions, + int defaultSuggestionIndex) = 0; + + // Notifies the WebView that AutoFill suggestions are available for a node. + virtual void applyAutoFillSuggestions( + const WebNode&, + const WebVector<WebString>& names, + const WebVector<WebString>& labels, + int defaultSuggestionIndex) = 0; + + // Notifies the WebView that Autocomplete suggestions are available for a + // node. + virtual void applyAutocompleteSuggestions( + const WebNode&, + const WebVector<WebString>& suggestions, + int defaultSuggestionIndex) = 0; + + // DEPRECATED: WebView::hideSuggestionsPopup is the new way to access this. + virtual void hideAutofillPopup() = 0; + + // Hides the suggestions popup if any are showing. + virtual void hideSuggestionsPopup() = 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(); + + + // Custom colors ------------------------------------------------------- + + virtual void setScrollbarColors(unsigned inactiveColor, + unsigned activeColor, + unsigned trackColor) = 0; + + virtual void setSelectionColors(unsigned activeBackgroundColor, + unsigned activeForegroundColor, + unsigned inactiveBackgroundColor, + unsigned inactiveForegroundColor) = 0; + + // User scripts -------------------------------------------------------- + virtual void addUserScript(const WebString& sourceCode, + bool runAtStart) = 0; + virtual void removeAllUserContent() = 0; + + // Modal dialog support ------------------------------------------------ + + // Call these methods before and after running a nested, modal event loop + // to suspend script callbacks and resource loads. + WEBKIT_API static void willEnterModalLoop(); + WEBKIT_API static void didExitModalLoop(); + +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..4d272bb --- /dev/null +++ b/WebKit/chromium/public/WebViewClient.h @@ -0,0 +1,286 @@ +/* + * 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 "WebFileChooserParams.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 WebStorageNamespace; +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. This method must clone its session storage + // so any subsequent calls to createSessionStorageNamespace conform to the + // WebStorage specification. + 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; } + + // Create a session storage namespace object associated with this WebView. + virtual WebStorageNamespace* createSessionStorageNamespace() { 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(const WebFileChooserParams&, + 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&) { } + + // Notifies embedder that the state of an accessibility object has changed. + virtual void didChangeAccessibilityObjectState(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/WebRenderTheme.h b/WebKit/chromium/public/linux/WebRenderTheme.h new file mode 100644 index 0000000..e3be69d --- /dev/null +++ b/WebKit/chromium/public/linux/WebRenderTheme.h @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2009 Joel Stanley. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (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 WebRenderTheme_h +#define WebRenderTheme_h + +#include "../WebCommon.h" + +namespace WebKit { + +// Set caret blink interval for text input areas. +WEBKIT_API void setCaretBlinkInterval(double); + +} // 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/APUAgentDelegate.h b/WebKit/chromium/src/APUAgentDelegate.h new file mode 100644 index 0000000..70be702 --- /dev/null +++ b/WebKit/chromium/src/APUAgentDelegate.h @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef APUAgentDelegate_h +#define APUAgentDelegate_h + +#include "DevToolsRPC.h" + +namespace WebKit { + +#define APU_AGENT_DELEGATE_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3, MEHTOD4, METHOD5) \ + /* Sends a json object to apu. */ \ + METHOD1(dispatchToApu, String /* data */) + +DEFINE_RPC_CLASS(ApuAgentDelegate, APU_AGENT_DELEGATE_STRUCT) + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/ApplicationCacheHost.cpp b/WebKit/chromium/src/ApplicationCacheHost.cpp new file mode 100644 index 0000000..5fa4a66 --- /dev/null +++ b/WebKit/chromium/src/ApplicationCacheHost.cpp @@ -0,0 +1,250 @@ +/* + * 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 "ApplicationCacheHostInternal.h" +#include "DocumentLoader.h" +#include "DOMApplicationCache.h" +#include "Frame.h" +#include "Settings.h" +#include "WebURL.h" +#include "WebURLError.h" +#include "WebURLResponse.h" +#include "WrappedResourceRequest.h" +#include "WrappedResourceResponse.h" + +using namespace WebKit; + +namespace WebCore { + +// 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) + , m_defersEvents(true) +{ + 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_defersEvents) { + m_deferredEvents.append(id); + return; + } + if (m_domApplicationCache) { + ExceptionCode ec = 0; + m_domApplicationCache->dispatchEvent(Event::create(DOMApplicationCache::toEventType(id), false, false), ec); + ASSERT(!ec); + } +} + +void ApplicationCacheHost::stopDeferringEvents() +{ + RefPtr<DocumentLoader> protect(documentLoader()); + for (unsigned i = 0; i < m_deferredEvents.size(); ++i) { + EventID id = m_deferredEvents[i]; + if (m_domApplicationCache) { + ExceptionCode ec = 0; + m_domApplicationCache->dispatchEvent(Event::create(DOMApplicationCache::toEventType(id), false, false), ec); + ASSERT(!ec); + } + } + m_deferredEvents.clear(); + m_defersEvents = false; +} + +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/ApplicationCacheHostInternal.h b/WebKit/chromium/src/ApplicationCacheHostInternal.h new file mode 100644 index 0000000..3e52c1b --- /dev/null +++ b/WebKit/chromium/src/ApplicationCacheHostInternal.h @@ -0,0 +1,70 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "ApplicationCacheHost.h" + +#if ENABLE(OFFLINE_WEB_APPLICATIONS) + +#include "WebApplicationCacheHostClient.h" +#include "WebKit.h" +#include "WebKitClient.h" + +namespace WebCore { + +class ApplicationCacheHostInternal : public WebKit::WebApplicationCacheHostClient { +public: + ApplicationCacheHostInternal(ApplicationCacheHost* host) + : m_innerHost(host) + { + m_outerHost.set(WebKit::webKitClient()->createApplicationCacheHost(this)); + } + + virtual void notifyEventListener(WebKit::WebApplicationCacheHost::EventID eventID) + { + m_innerHost->notifyDOMApplicationCache(static_cast<ApplicationCacheHost::EventID>(eventID)); + } + + static WebKit::WebApplicationCacheHost* toWebApplicationCacheHost(ApplicationCacheHost* innerHost) + { + if (innerHost && innerHost->m_internal.get()) + return innerHost->m_internal->m_outerHost.get(); + return 0; + } + +private: + friend class ApplicationCacheHost; + ApplicationCacheHost* m_innerHost; + OwnPtr<WebKit::WebApplicationCacheHost> m_outerHost; +}; + +} + +#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..1d2948f --- /dev/null +++ b/WebKit/chromium/src/AssertMatchingEnums.cpp @@ -0,0 +1,298 @@ +/* + * 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(WebAccessibilityRoleMenuListOption, MenuListOptionRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleMenuListPopup, MenuListPopupRole); +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(WebAccessibilityRoleTreeGrid, TreeGridRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleTreeItemRole, TreeItemRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleDirectory, DirectoryRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleEditableText, EditableTextRole); +COMPILE_ASSERT_MATCHING_ENUM(WebAccessibilityRoleListItem, ListItemRole); +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); + +COMPILE_ASSERT_MATCHING_ENUM(WebNode::ElementNode, Node::ELEMENT_NODE); +COMPILE_ASSERT_MATCHING_ENUM(WebNode::AttributeNode, Node::ATTRIBUTE_NODE); +COMPILE_ASSERT_MATCHING_ENUM(WebNode::TextNode, Node::TEXT_NODE); +COMPILE_ASSERT_MATCHING_ENUM(WebNode::CDataSectionNode, Node::CDATA_SECTION_NODE); +COMPILE_ASSERT_MATCHING_ENUM(WebNode::EntityReferenceNode, Node::ENTITY_REFERENCE_NODE); +COMPILE_ASSERT_MATCHING_ENUM(WebNode::EntityNode, Node::ENTITY_NODE); +COMPILE_ASSERT_MATCHING_ENUM(WebNode::ProcessingInstructionsNode, Node::PROCESSING_INSTRUCTION_NODE); +COMPILE_ASSERT_MATCHING_ENUM(WebNode::CommentNode, Node::COMMENT_NODE); +COMPILE_ASSERT_MATCHING_ENUM(WebNode::DocumentNode, Node::DOCUMENT_NODE); +COMPILE_ASSERT_MATCHING_ENUM(WebNode::DocumentTypeNode, Node::DOCUMENT_TYPE_NODE); +COMPILE_ASSERT_MATCHING_ENUM(WebNode::DocumentFragmentNode, Node::DOCUMENT_FRAGMENT_NODE); +COMPILE_ASSERT_MATCHING_ENUM(WebNode::NotationNode, Node::NOTATION_NODE); +COMPILE_ASSERT_MATCHING_ENUM(WebNode::XPathNamespaceNode, Node::XPATH_NAMESPACE_NODE); + +#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/AutoFillPopupMenuClient.cpp b/WebKit/chromium/src/AutoFillPopupMenuClient.cpp new file mode 100644 index 0000000..8e6cab4 --- /dev/null +++ b/WebKit/chromium/src/AutoFillPopupMenuClient.cpp @@ -0,0 +1,95 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "AutoFillPopupMenuClient.h" + +#include "HTMLInputElement.h" +#include "WebString.h" +#include "WebVector.h" + +using namespace WebCore; + +namespace WebKit { + +unsigned AutoFillPopupMenuClient::getSuggestionsCount() const +{ + return m_names.size(); +} + +WebString AutoFillPopupMenuClient::getSuggestion(unsigned listIndex) const +{ + // FIXME: Modify the PopupMenu to add the label in gray right-justified. + ASSERT(listIndex >= 0 && listIndex < m_names.size()); + return m_names[listIndex] + String(" (") + m_labels[listIndex] + String(")"); +} + +void AutoFillPopupMenuClient::removeSuggestionAtIndex(unsigned listIndex) +{ + // FIXME: Do we want to remove AutoFill suggestions? + ASSERT(listIndex >= 0 && listIndex < m_names.size()); + m_names.remove(listIndex); + m_labels.remove(listIndex); +} + +void AutoFillPopupMenuClient::initialize( + HTMLInputElement* textField, + const WebVector<WebString>& names, + const WebVector<WebString>& labels, + int defaultSuggestionIndex) +{ + ASSERT(names.size() == labels.size()); + ASSERT(defaultSuggestionIndex < static_cast<int>(names.size())); + + // The suggestions must be set before initializing the + // SuggestionsPopupMenuClient. + setSuggestions(names, labels); + + SuggestionsPopupMenuClient::initialize(textField, defaultSuggestionIndex); +} + +void AutoFillPopupMenuClient::setSuggestions(const WebVector<WebString>& names, + const WebVector<WebString>& labels) +{ + ASSERT(names.size() == labels.size()); + + m_names.clear(); + m_labels.clear(); + for (size_t i = 0; i < names.size(); ++i) { + m_names.append(names[i]); + m_labels.append(labels[i]); + } + + // Try to preserve selection if possible. + if (getSelectedIndex() >= static_cast<int>(names.size())) + setSelectedIndex(-1); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/AutoFillPopupMenuClient.h b/WebKit/chromium/src/AutoFillPopupMenuClient.h new file mode 100644 index 0000000..1912fa3 --- /dev/null +++ b/WebKit/chromium/src/AutoFillPopupMenuClient.h @@ -0,0 +1,68 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef AutoFillPopupMenuClient_h +#define AutoFillPopupMenuClient_h + +#include "SuggestionsPopupMenuClient.h" + +namespace WebCore { +class HTMLInputElement; +} + +namespace WebKit { +class WebString; +template <typename T> class WebVector; + +// The AutoFill suggestions popup menu client, used to display name suggestions +// with right-justified labels. +class AutoFillPopupMenuClient : public SuggestionsPopupMenuClient { +public: + // SuggestionsPopupMenuClient implementation: + virtual unsigned getSuggestionsCount() const; + virtual WebString getSuggestion(unsigned listIndex) const; + virtual void removeSuggestionAtIndex(unsigned listIndex); + + void initialize(WebCore::HTMLInputElement*, + const WebVector<WebString>& names, + const WebVector<WebString>& labels, + int defaultSuggestionIndex); + + void setSuggestions(const WebVector<WebString>& names, + const WebVector<WebString>& labels); + +private: + Vector<WebCore::String> m_names; + Vector<WebCore::String> m_labels; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/AutocompletePopupMenuClient.cpp b/WebKit/chromium/src/AutocompletePopupMenuClient.cpp new file mode 100644 index 0000000..9620ffc --- /dev/null +++ b/WebKit/chromium/src/AutocompletePopupMenuClient.cpp @@ -0,0 +1,84 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "AutocompletePopupMenuClient.h" + +#include "HTMLInputElement.h" +#include "WebString.h" +#include "WebVector.h" + +using namespace WebCore; + +namespace WebKit { + +unsigned AutocompletePopupMenuClient::getSuggestionsCount() const +{ + return m_suggestions.size(); +} + +WebString AutocompletePopupMenuClient::getSuggestion(unsigned listIndex) const +{ + ASSERT(listIndex >= 0 && listIndex < m_suggestions.size()); + return m_suggestions[listIndex]; +} + +void AutocompletePopupMenuClient::removeSuggestionAtIndex(unsigned listIndex) +{ + ASSERT(listIndex >= 0 && listIndex < m_suggestions.size()); + m_suggestions.remove(listIndex); +} + +void AutocompletePopupMenuClient::initialize( + HTMLInputElement* textField, + const WebVector<WebString>& suggestions, + int defaultSuggestionIndex) +{ + ASSERT(defaultSuggestionIndex < static_cast<int>(suggestions.size())); + + // The suggestions must be set before initializing the + // SuggestionsPopupMenuClient. + setSuggestions(suggestions); + + SuggestionsPopupMenuClient::initialize(textField, defaultSuggestionIndex); +} + +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 (getSelectedIndex() >= static_cast<int>(suggestions.size())) + setSelectedIndex(-1); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/AutocompletePopupMenuClient.h b/WebKit/chromium/src/AutocompletePopupMenuClient.h new file mode 100644 index 0000000..16a3771 --- /dev/null +++ b/WebKit/chromium/src/AutocompletePopupMenuClient.h @@ -0,0 +1,65 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef AutocompletePopupMenuClient_h +#define AutocompletePopupMenuClient_h + +#include "SuggestionsPopupMenuClient.h" + +namespace WebCore { +class HTMLInputElement; +} + +namespace WebKit { +class WebString; +template <typename T> class WebVector; + +// The Autocomplete suggestions popup menu client, used to display a list of +// autocomplete suggestions. +class AutocompletePopupMenuClient : public SuggestionsPopupMenuClient { +public: + // SuggestionsPopupMenuClient implementation: + virtual unsigned getSuggestionsCount() const; + virtual WebString getSuggestion(unsigned listIndex) const; + virtual void removeSuggestionAtIndex(unsigned listIndex); + + void initialize(WebCore::HTMLInputElement*, + const WebVector<WebString>& suggestions, + int defaultSuggestionIndex); + + void setSuggestions(const WebVector<WebString>&); + +private: + Vector<WebCore::String> m_suggestions; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/BackForwardListClientImpl.cpp b/WebKit/chromium/src/BackForwardListClientImpl.cpp new file mode 100644 index 0000000..f5b04ab --- /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() || index > forwardListCount() || -index > backListCount()) + 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/BoundObject.cpp b/WebKit/chromium/src/BoundObject.cpp new file mode 100644 index 0000000..90096c2 --- /dev/null +++ b/WebKit/chromium/src/BoundObject.cpp @@ -0,0 +1,79 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "BoundObject.h" + +#include "V8Proxy.h" + +namespace WebKit { + +BoundObject::BoundObject(v8::Handle<v8::Context> context, void* v8This, const char* objectName) + : m_objectName(objectName) + , m_context(context) + , m_v8This(v8This) +{ + v8::Context::Scope contextScope(context); + v8::Local<v8::FunctionTemplate> localTemplate = v8::FunctionTemplate::New(WebCore::V8Proxy::checkNewLegal); + m_hostTemplate = v8::Persistent<v8::FunctionTemplate>::New(localTemplate); + m_hostTemplate->SetClassName(v8::String::New(objectName)); +} + +BoundObject::~BoundObject() +{ + m_hostTemplate.Dispose(); +} + +void BoundObject::addProtoFunction(const char* name, v8::InvocationCallback callback) +{ + v8::Context::Scope contextScope(m_context); + v8::Local<v8::Signature> signature = v8::Signature::New(m_hostTemplate); + v8::Local<v8::ObjectTemplate> proto = m_hostTemplate->PrototypeTemplate(); + v8::Local<v8::External> v8This = v8::External::New(m_v8This); + proto->Set( + v8::String::New(name), + v8::FunctionTemplate::New( + callback, + v8This, + signature), + static_cast<v8::PropertyAttribute>(v8::DontDelete)); +} + +void BoundObject::build() +{ + v8::Context::Scope contextScope(m_context); + v8::Local<v8::Function> constructor = m_hostTemplate->GetFunction(); + v8::Local<v8::Object> boundObject = WebCore::SafeAllocation::newInstance(constructor); + + v8::Handle<v8::Object> global = m_context->Global(); + global->Set(v8::String::New(m_objectName), boundObject); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/BoundObject.h b/WebKit/chromium/src/BoundObject.h new file mode 100644 index 0000000..769e83f --- /dev/null +++ b/WebKit/chromium/src/BoundObject.h @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef BoundObject_h +#define BoundObject_h + +#include <v8.h> +#include <wtf/Noncopyable.h> + +namespace WebKit { + +// BoundObject is a helper class that lets you map JavaScript method calls +// directly to C++ method calls. It should be destroyed once JS object is +// built. +class BoundObject : public Noncopyable { +public: + BoundObject(v8::Handle<v8::Context> context, void* v8This, const char* objectName); + virtual ~BoundObject(); + + void addProtoFunction(const char* name, v8::InvocationCallback callback); + void build(); + +private: + v8::HandleScope m_handleScope; + const char* m_objectName; + v8::Handle<v8::Context> m_context; + v8::Persistent<v8::FunctionTemplate> m_hostTemplate; + void* m_v8This; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/ChromeClientImpl.cpp b/WebKit/chromium/src/ChromeClientImpl.cpp new file mode 100644 index 0000000..ce2f00c --- /dev/null +++ b/WebKit/chromium/src/ChromeClientImpl.cpp @@ -0,0 +1,677 @@ +/* + * 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; + + WebFileChooserParams params; + params.multiSelect = fileChooser->allowsMultipleFiles(); + params.acceptTypes = fileChooser->acceptTypes(); + params.selectedFiles = fileChooser->filenames(); + if (params.selectedFiles.size() > 0) + params.initialValue = params.selectedFiles[0]; + WebFileChooserCompletionImpl* chooserCompletion = + new WebFileChooserCompletionImpl(fileChooser); + + if (client->runFileChooser(params, chooserCompletion)) + return; + + // 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); +} + +void ChromeClientImpl::didChangeAccessibilityObjectState(AccessibilityObject* obj) +{ + // Alert assistive technology about the accessibility object state change + if (obj) + m_webView->client()->didChangeAccessibilityObjectState(WebAccessibilityObject(obj)); +} + + +#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..9e8c2e3 --- /dev/null +++ b/WebKit/chromium/src/ChromeClientImpl.h @@ -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. + */ + +#ifndef ChromeClientImpl_h +#define ChromeClientImpl_h + +#include "ChromeClientChromium.h" + +namespace WebCore { +class AccessibilityObject; +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); + virtual void didChangeAccessibilityObjectState(WebCore::AccessibilityObject*); + + // 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..0fd0825 --- /dev/null +++ b/WebKit/chromium/src/ChromiumBridge.cpp @@ -0,0 +1,696 @@ +/* + * 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 "Chrome.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 OS(WINDOWS) +#include "WebRect.h" +#include "WebSandboxSupport.h" +#include "WebThemeEngine.h" +#endif + +#if OS(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); +} + +bool ChromiumBridge::cookiesEnabled(const KURL& url, + const KURL& firstPartyForCookies) +{ + return webKitClient()->cookiesEnabled(url, firstPartyForCookies); +} + +// 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 OS(WINDOWS) +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 OS(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 OS(WINDOWS) + +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..8472082 --- /dev/null +++ b/WebKit/chromium/src/ContextMenuClientImpl.cpp @@ -0,0 +1,291 @@ +/* + * 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 "CSSPropertyNames.h" +#include "CSSStyleDeclaration.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. +static bool isASingleWord(const String& text) +{ + TextBreakIterator* it = wordBreakIterator(text.characters(), text.length()); + return it && textBreakNext(it) == static_cast<int>(text.length()); +} + +// 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 on OS X. +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())); + + if (pos.isNull()) + return misspelledWord; // It is empty. + + WebFrameImpl::selectWordAroundPosition(selectedFrame, pos); + misspelledWord = selectedFrame->selectedText().stripWhiteSpace(); + +#if OS(DARWIN) + // 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()) + selectedFrame->selection()->setSelection(VisibleSelection(pos)); +#else + // On non-Mac, right-click should not make a range selection in any case. + selectedFrame->selection()->setSelection(VisibleSelection(pos)); +#endif + 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); + } + } + +#if OS(DARWIN) + // Writing direction context menu. + data.writingDirectionDefault = WebContextMenuData::CheckableMenuItemDisabled; + data.writingDirectionLeftToRight = WebContextMenuData::CheckableMenuItemEnabled; + data.writingDirectionRightToLeft = WebContextMenuData::CheckableMenuItemEnabled; + + ExceptionCode ec = 0; + RefPtr<CSSStyleDeclaration> style = selectedFrame->document()->createCSSStyleDeclaration(); + style->setProperty(CSSPropertyDirection, "ltr", false, ec); + if (selectedFrame->editor()->selectionHasStyle(style.get()) != FalseTriState) + data.writingDirectionLeftToRight |= WebContextMenuData::CheckableMenuItemChecked; + style->setProperty(CSSPropertyDirection, "rtl", false, ec); + if (selectedFrame->editor()->selectionHasStyle(style.get()) != FalseTriState) + data.writingDirectionRightToLeft |= WebContextMenuData::CheckableMenuItemChecked; +#endif // OS(DARWIN) + + // 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..4081db6 --- /dev/null +++ b/WebKit/chromium/src/DOMUtilitiesPrivate.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 "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(); +} + +bool elementHasLegalLinkAttribute(const Element* element, + const QualifiedName& attrName) +{ + if (attrName == HTMLNames::srcAttr) { + // Check src attribute. + if (element->hasTagName(HTMLNames::imgTag) + || element->hasTagName(HTMLNames::scriptTag) + || element->hasTagName(HTMLNames::iframeTag) + || element->hasTagName(HTMLNames::frameTag)) + return true; + if (element->hasTagName(HTMLNames::inputTag)) { + const HTMLInputElement* input = + static_cast<const HTMLInputElement*>(element); + if (input->inputType() == HTMLInputElement::IMAGE) + return true; + } + } else if (attrName == HTMLNames::hrefAttr) { + // Check href attribute. + if (element->hasTagName(HTMLNames::linkTag) + || element->hasTagName(HTMLNames::aTag) + || element->hasTagName(HTMLNames::areaTag)) + return true; + } else if (attrName == HTMLNames::actionAttr) { + if (element->hasTagName(HTMLNames::formTag)) + return true; + } else if (attrName == HTMLNames::backgroundAttr) { + if (element->hasTagName(HTMLNames::bodyTag) + || element->hasTagName(HTMLNames::tableTag) + || element->hasTagName(HTMLNames::trTag) + || element->hasTagName(HTMLNames::tdTag)) + return true; + } else if (attrName == HTMLNames::citeAttr) { + if (element->hasTagName(HTMLNames::blockquoteTag) + || element->hasTagName(HTMLNames::qTag) + || element->hasTagName(HTMLNames::delTag) + || element->hasTagName(HTMLNames::insTag)) + return true; + } else if (attrName == HTMLNames::classidAttr + || attrName == HTMLNames::dataAttr) { + if (element->hasTagName(HTMLNames::objectTag)) + return true; + } else if (attrName == HTMLNames::codebaseAttr) { + if (element->hasTagName(HTMLNames::objectTag) + || element->hasTagName(HTMLNames::appletTag)) + return true; + } + return false; +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/DOMUtilitiesPrivate.h b/WebKit/chromium/src/DOMUtilitiesPrivate.h new file mode 100644 index 0000000..253ab3f --- /dev/null +++ b/WebKit/chromium/src/DOMUtilitiesPrivate.h @@ -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. + */ + +#ifndef DOMUtilitiesPrivate_h +#define DOMUtilitiesPrivate_h + +namespace WebCore { +class Element; +class HTMLInputElement; +class HTMLLinkElement; +class HTMLMetaElement; +class HTMLOptionElement; +class Node; +class QualifiedName; +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*); + +// For img, script, iframe, frame element, when attribute name is src, +// for link, a, area element, when attribute name is href, +// for form element, when attribute name is action, +// for input, type=image, when attribute name is src, +// for body, table, tr, td, when attribute name is background, +// for blockquote, q, del, ins, when attribute name is cite, +// we can consider the attribute value has legal link. +bool elementHasLegalLinkAttribute(const WebCore::Element* element, + const WebCore::QualifiedName& attrName); + +} // 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/DebuggerAgent.h b/WebKit/chromium/src/DebuggerAgent.h new file mode 100644 index 0000000..17cde11 --- /dev/null +++ b/WebKit/chromium/src/DebuggerAgent.h @@ -0,0 +1,57 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef DebuggerAgent_h +#define DebuggerAgent_h + +#include "DevToolsRPC.h" + +namespace WebKit { + +#define DEBUGGER_AGENT_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3, METHOD4, METHOD5) \ + /* Requests global context id of the inspected tab. */ \ + METHOD0(getContextId) \ + \ + /* Request v8 to process all debug commands in the queue. */ \ + METHOD0(processDebugCommands) + +DEFINE_RPC_CLASS(DebuggerAgent, DEBUGGER_AGENT_STRUCT) + +#define DEBUGGER_AGENT_DELEGATE_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3, METHOD4, METHOD5) \ + METHOD1(debuggerOutput, String /* output text */) \ + \ + /* Pushes debugger context id into the client. */ \ + METHOD1(setContextId, int /* context id */) + +DEFINE_RPC_CLASS(DebuggerAgentDelegate, DEBUGGER_AGENT_DELEGATE_STRUCT) + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/DebuggerAgentImpl.cpp b/WebKit/chromium/src/DebuggerAgentImpl.cpp new file mode 100644 index 0000000..d592710 --- /dev/null +++ b/WebKit/chromium/src/DebuggerAgentImpl.cpp @@ -0,0 +1,203 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "DebuggerAgentImpl.h" + +#include "DebuggerAgentManager.h" +#include "Document.h" +#include "Frame.h" +#include "Page.h" +#include "V8Binding.h" +#include "V8DOMWindow.h" +#include "V8Index.h" +#include "V8Proxy.h" +#include "WebDevToolsAgentImpl.h" +#include "WebViewImpl.h" +#include <wtf/HashSet.h> +#include <wtf/RefPtr.h> +#include <wtf/Vector.h> + +using WebCore::DOMWindow; +using WebCore::Document; +using WebCore::Frame; +using WebCore::Page; +using WebCore::String; +using WebCore::V8ClassIndex; +using WebCore::V8DOMWindow; +using WebCore::V8DOMWrapper; +using WebCore::V8Proxy; + +namespace WebKit { + +DebuggerAgentImpl::DebuggerAgentImpl( + WebViewImpl* webViewImpl, + DebuggerAgentDelegate* delegate, + WebDevToolsAgentImpl* webdevtoolsAgent) + : m_webViewImpl(webViewImpl) + , m_delegate(delegate) + , m_webdevtoolsAgent(webdevtoolsAgent) + , m_autoContinueOnException(false) +{ + DebuggerAgentManager::debugAttach(this); +} + +DebuggerAgentImpl::~DebuggerAgentImpl() +{ + DebuggerAgentManager::debugDetach(this); +} + +void DebuggerAgentImpl::getContextId() +{ + m_delegate->setContextId(m_webdevtoolsAgent->hostId()); +} + +void DebuggerAgentImpl::processDebugCommands() +{ + DebuggerAgentManager::UtilityContextScope utilityScope; + v8::Debug::ProcessDebugMessages(); +} + +void DebuggerAgentImpl::debuggerOutput(const String& command) +{ + m_delegate->debuggerOutput(command); + m_webdevtoolsAgent->forceRepaint(); +} + +// static +void DebuggerAgentImpl::createUtilityContext(Frame* frame, v8::Persistent<v8::Context>* context) +{ + v8::HandleScope scope; + bool canExecuteScripts = frame->script()->canExecuteScripts(); + + // Set up the DOM window as the prototype of the new global object. + v8::Handle<v8::Context> windowContext = V8Proxy::context(frame); + v8::Handle<v8::Object> windowGlobal; + v8::Handle<v8::Object> windowWrapper; + if (canExecuteScripts) { + // FIXME: This check prevents renderer from crashing, while providing limited capabilities for + // DOM inspection, Resources tracking, no scripts support, some timeline profiling. Console will + // result in exceptions for each evaluation. There is still some work that needs to be done in + // order to polish the script-less experience. + windowGlobal = windowContext->Global(); + windowWrapper = V8DOMWrapper::lookupDOMWrapper(V8DOMWindow::GetTemplate(), windowGlobal); + ASSERT(V8DOMWindow::toNative(windowWrapper) == frame->domWindow()); + } + + v8::Handle<v8::ObjectTemplate> globalTemplate = v8::ObjectTemplate::New(); + + // TODO(yurys): provide a function in v8 bindings that would make the + // utility context more like main world context of the inspected frame, + // otherwise we need to manually make it satisfy various invariants + // that V8Proxy::getEntered and some other V8Proxy methods expect to find + // on v8 contexts on the contexts stack. + // See V8Proxy::createNewContext. + // + // Install a security handler with V8. + globalTemplate->SetAccessCheckCallbacks( + V8DOMWindow::namedSecurityCheck, + V8DOMWindow::indexedSecurityCheck, + v8::Integer::New(V8ClassIndex::DOMWINDOW)); + // We set number of internal fields to match that in V8DOMWindow wrapper. + // See http://crbug.com/28961 + globalTemplate->SetInternalFieldCount(V8DOMWindow::internalFieldCount); + + *context = v8::Context::New(0 /* no extensions */, globalTemplate, v8::Handle<v8::Object>()); + v8::Context::Scope contextScope(*context); + v8::Handle<v8::Object> global = (*context)->Global(); + + v8::Handle<v8::String> implicitProtoString = v8::String::New("__proto__"); + if (canExecuteScripts) + global->Set(implicitProtoString, windowWrapper); + + // Give the code running in the new context a way to get access to the + // original context. + if (canExecuteScripts) + global->Set(v8::String::New("contentWindow"), windowGlobal); +} + +String DebuggerAgentImpl::executeUtilityFunction( + v8::Handle<v8::Context> context, + int callId, + const char* object, + const String &functionName, + const String& jsonArgs, + bool async, + String* exception) +{ + v8::HandleScope scope; + ASSERT(!context.IsEmpty()); + if (context.IsEmpty()) { + *exception = "No window context."; + return ""; + } + v8::Context::Scope contextScope(context); + + DebuggerAgentManager::UtilityContextScope utilityScope; + + v8::Handle<v8::Object> dispatchObject = v8::Handle<v8::Object>::Cast( + context->Global()->Get(v8::String::New(object))); + + v8::Handle<v8::Value> dispatchFunction = dispatchObject->Get(v8::String::New("dispatch")); + ASSERT(dispatchFunction->IsFunction()); + v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(dispatchFunction); + + v8::Handle<v8::String> functionNameWrapper = v8::Handle<v8::String>( + v8::String::New(functionName.utf8().data())); + v8::Handle<v8::String> jsonArgsWrapper = v8::Handle<v8::String>( + v8::String::New(jsonArgs.utf8().data())); + v8::Handle<v8::Number> callIdWrapper = v8::Handle<v8::Number>( + v8::Number::New(async ? callId : 0)); + + v8::Handle<v8::Value> args[] = { + functionNameWrapper, + jsonArgsWrapper, + callIdWrapper + }; + + v8::TryCatch tryCatch; + v8::Handle<v8::Value> resObj = function->Call(context->Global(), 3, args); + if (tryCatch.HasCaught()) { + v8::Local<v8::Message> message = tryCatch.Message(); + if (message.IsEmpty()) + *exception = "Unknown exception"; + else + *exception = WebCore::toWebCoreString(message->Get()); + return ""; + } + return WebCore::toWebCoreStringWithNullCheck(resObj); +} + +WebCore::Page* DebuggerAgentImpl::page() +{ + return m_webViewImpl->page(); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/DebuggerAgentImpl.h b/WebKit/chromium/src/DebuggerAgentImpl.h new file mode 100644 index 0000000..6eaf576 --- /dev/null +++ b/WebKit/chromium/src/DebuggerAgentImpl.h @@ -0,0 +1,100 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef DebuggerAgentImpl_h +#define DebuggerAgentImpl_h + +#include "DebuggerAgent.h" + +#include <v8.h> +#include <wtf/HashSet.h> +#include <wtf/Noncopyable.h> + +namespace WebCore { +class Document; +class Frame; +class Node; +class Page; +class String; +} + +namespace WebKit { + +class WebDevToolsAgentImpl; +class WebViewImpl; + +class DebuggerAgentImpl : public DebuggerAgent { +public: + // Creates utility context with injected js agent. + static void createUtilityContext(WebCore::Frame* frame, v8::Persistent<v8::Context>* context); + + DebuggerAgentImpl(WebKit::WebViewImpl* webViewImpl, + DebuggerAgentDelegate* delegate, + WebDevToolsAgentImpl* webdevtoolsAgent); + virtual ~DebuggerAgentImpl(); + + // DebuggerAgent implementation. + virtual void getContextId(); + virtual void processDebugCommands(); + + void debuggerOutput(const WebCore::String& out); + + void setAutoContinueOnException(bool autoContinue) { m_autoContinueOnException = autoContinue; } + + bool autoContinueOnException() { return m_autoContinueOnException; } + + // Executes function with the given name in the utility context. Passes node + // and json args as parameters. Note that the function called must be + // implemented in the inject_dispatch.js file. + WebCore::String executeUtilityFunction( + v8::Handle<v8::Context> context, + int callId, + const char* object, + const WebCore::String& functionName, + const WebCore::String& jsonArgs, + bool async, + WebCore::String* exception); + + + WebCore::Page* page(); + WebDevToolsAgentImpl* webdevtoolsAgent() { return m_webdevtoolsAgent; } + + WebKit::WebViewImpl* webView() { return m_webViewImpl; } + +private: + WebKit::WebViewImpl* m_webViewImpl; + DebuggerAgentDelegate* m_delegate; + WebDevToolsAgentImpl* m_webdevtoolsAgent; + bool m_autoContinueOnException; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/DebuggerAgentManager.cpp b/WebKit/chromium/src/DebuggerAgentManager.cpp new file mode 100644 index 0000000..faafaff --- /dev/null +++ b/WebKit/chromium/src/DebuggerAgentManager.cpp @@ -0,0 +1,311 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "DebuggerAgentManager.h" + +#include "DebuggerAgentImpl.h" +#include "Frame.h" +#include "PageGroupLoadDeferrer.h" +#include "V8Proxy.h" +#include "WebDevToolsAgentImpl.h" +#include "WebFrameImpl.h" +#include "WebViewImpl.h" +#include <wtf/HashSet.h> +#include <wtf/Noncopyable.h> + +namespace WebKit { + +WebDevToolsAgent::MessageLoopDispatchHandler DebuggerAgentManager::s_messageLoopDispatchHandler = 0; + +bool DebuggerAgentManager::s_inHostDispatchHandler = false; + +DebuggerAgentManager::DeferrersMap DebuggerAgentManager::s_pageDeferrers; + +bool DebuggerAgentManager::s_inUtilityContext = false; + +bool DebuggerAgentManager::s_debugBreakDelayed = false; + +namespace { + +class CallerIdWrapper : public v8::Debug::ClientData, public Noncopyable { +public: + CallerIdWrapper() : m_callerIsMananager(true), m_callerId(0) { } + explicit CallerIdWrapper(int callerId) + : m_callerIsMananager(false) + , m_callerId(callerId) { } + ~CallerIdWrapper() { } + bool callerIsMananager() const { return m_callerIsMananager; } + int callerId() const { return m_callerId; } +private: + bool m_callerIsMananager; + int m_callerId; +}; + +} // namespace + + +void DebuggerAgentManager::debugHostDispatchHandler() +{ + if (!s_messageLoopDispatchHandler || !s_attachedAgentsMap) + return; + + if (s_inHostDispatchHandler) + return; + + s_inHostDispatchHandler = true; + + Vector<WebViewImpl*> views; + // 1. Disable active objects and input events. + for (AttachedAgentsMap::iterator it = s_attachedAgentsMap->begin(); it != s_attachedAgentsMap->end(); ++it) { + DebuggerAgentImpl* agent = it->second; + s_pageDeferrers.set(agent->webView(), new WebCore::PageGroupLoadDeferrer(agent->page(), true)); + views.append(agent->webView()); + agent->webView()->setIgnoreInputEvents(true); + } + + // 2. Process messages. + s_messageLoopDispatchHandler(); + + // 3. Bring things back. + for (Vector<WebViewImpl*>::iterator it = views.begin(); it != views.end(); ++it) { + if (s_pageDeferrers.contains(*it)) { + // The view was not closed during the dispatch. + (*it)->setIgnoreInputEvents(false); + } + } + deleteAllValues(s_pageDeferrers); + s_pageDeferrers.clear(); + + s_inHostDispatchHandler = false; + if (!s_attachedAgentsMap) { + // Remove handlers if all agents were detached within host dispatch. + v8::Debug::SetMessageHandler(0); + v8::Debug::SetHostDispatchHandler(0); + } +} + +DebuggerAgentManager::AttachedAgentsMap* DebuggerAgentManager::s_attachedAgentsMap = 0; + +void DebuggerAgentManager::debugAttach(DebuggerAgentImpl* debuggerAgent) +{ + if (!s_attachedAgentsMap) { + s_attachedAgentsMap = new AttachedAgentsMap(); + v8::Debug::SetMessageHandler2(&DebuggerAgentManager::onV8DebugMessage); + v8::Debug::SetHostDispatchHandler(&DebuggerAgentManager::debugHostDispatchHandler, 100 /* ms */); + } + int hostId = debuggerAgent->webdevtoolsAgent()->hostId(); + ASSERT(hostId); + s_attachedAgentsMap->set(hostId, debuggerAgent); +} + +void DebuggerAgentManager::debugDetach(DebuggerAgentImpl* debuggerAgent) +{ + if (!s_attachedAgentsMap) { + ASSERT_NOT_REACHED(); + return; + } + int hostId = debuggerAgent->webdevtoolsAgent()->hostId(); + ASSERT(s_attachedAgentsMap->get(hostId) == debuggerAgent); + bool isOnBreakpoint = (findAgentForCurrentV8Context() == debuggerAgent); + s_attachedAgentsMap->remove(hostId); + + if (s_attachedAgentsMap->isEmpty()) { + delete s_attachedAgentsMap; + s_attachedAgentsMap = 0; + // Note that we do not empty handlers while in dispatch - we schedule + // continue and do removal once we are out of the dispatch. Also there is + // no need to send continue command in this case since removing message + // handler will cause debugger unload and all breakpoints will be cleared. + if (!s_inHostDispatchHandler) { + v8::Debug::SetMessageHandler2(0); + v8::Debug::SetHostDispatchHandler(0); + } + } else { + // Remove all breakpoints set by the agent. + String clearBreakpointGroupCmd = String::format( + "{\"seq\":1,\"type\":\"request\",\"command\":\"clearbreakpointgroup\"," + "\"arguments\":{\"groupId\":%d}}", + hostId); + sendCommandToV8(clearBreakpointGroupCmd, new CallerIdWrapper()); + + if (isOnBreakpoint) { + // Force continue if detach happened in nessted message loop while + // debugger was paused on a breakpoint(as long as there are other + // attached agents v8 will wait for explicit'continue' message). + sendContinueCommandToV8(); + } + } +} + +void DebuggerAgentManager::onV8DebugMessage(const v8::Debug::Message& message) +{ + v8::HandleScope scope; + v8::String::Value value(message.GetJSON()); + String out(reinterpret_cast<const UChar*>(*value), value.length()); + + // If callerData is not 0 the message is a response to a debugger command. + if (v8::Debug::ClientData* callerData = message.GetClientData()) { + CallerIdWrapper* wrapper = static_cast<CallerIdWrapper*>(callerData); + if (wrapper->callerIsMananager()) { + // Just ignore messages sent by this manager. + return; + } + DebuggerAgentImpl* debuggerAgent = debuggerAgentForHostId(wrapper->callerId()); + if (debuggerAgent) + debuggerAgent->debuggerOutput(out); + else if (!message.WillStartRunning()) { + // Autocontinue execution if there is no handler. + sendContinueCommandToV8(); + } + return; + } // Otherwise it's an event message. + ASSERT(message.IsEvent()); + + // Ignore unsupported event types. + if (message.GetEvent() != v8::AfterCompile && message.GetEvent() != v8::Break && message.GetEvent() != v8::Exception) + return; + + v8::Handle<v8::Context> context = message.GetEventContext(); + // If the context is from one of the inpected tabs it should have its context + // data. + if (context.IsEmpty()) { + // Unknown context, skip the event. + return; + } + + if (s_inUtilityContext && message.GetEvent() == v8::Break) { + // This may happen when two tabs are being debugged in the same process. + // Suppose that first debugger is pauesed on an exception. It will run + // nested MessageLoop which may process Break request from the second + // debugger. + s_debugBreakDelayed = true; + } else { + // If the context is from one of the inpected tabs or injected extension + // scripts it must have hostId in the data field. + int hostId = WebCore::V8Proxy::contextDebugId(context); + if (hostId != -1) { + DebuggerAgentImpl* agent = debuggerAgentForHostId(hostId); + if (agent) { + if (agent->autoContinueOnException() + && message.GetEvent() == v8::Exception) { + sendContinueCommandToV8(); + return; + } + + agent->debuggerOutput(out); + return; + } + } + } + + if (!message.WillStartRunning()) { + // Autocontinue execution on break and exception events if there is no + // handler. + sendContinueCommandToV8(); + } +} + +void DebuggerAgentManager::pauseScript() +{ + if (s_inUtilityContext) + s_debugBreakDelayed = true; + else + v8::Debug::DebugBreak(); +} + +void DebuggerAgentManager::executeDebuggerCommand(const String& command, int callerId) +{ + sendCommandToV8(command, new CallerIdWrapper(callerId)); +} + +void DebuggerAgentManager::setMessageLoopDispatchHandler(WebDevToolsAgent::MessageLoopDispatchHandler handler) +{ + s_messageLoopDispatchHandler = handler; +} + +void DebuggerAgentManager::setHostId(WebFrameImpl* webframe, int hostId) +{ + ASSERT(hostId > 0); + WebCore::V8Proxy* proxy = WebCore::V8Proxy::retrieve(webframe->frame()); + if (proxy) + proxy->setContextDebugId(hostId); +} + +void DebuggerAgentManager::onWebViewClosed(WebViewImpl* webview) +{ + if (s_pageDeferrers.contains(webview)) { + delete s_pageDeferrers.get(webview); + s_pageDeferrers.remove(webview); + } +} + +void DebuggerAgentManager::onNavigate() +{ + if (s_inHostDispatchHandler) + DebuggerAgentManager::sendContinueCommandToV8(); +} + +void DebuggerAgentManager::sendCommandToV8(const String& cmd, v8::Debug::ClientData* data) +{ + v8::Debug::SendCommand(reinterpret_cast<const uint16_t*>(cmd.characters()), cmd.length(), data); +} + +void DebuggerAgentManager::sendContinueCommandToV8() +{ + String continueCmd("{\"seq\":1,\"type\":\"request\",\"command\":\"continue\"}"); + sendCommandToV8(continueCmd, new CallerIdWrapper()); +} + +DebuggerAgentImpl* DebuggerAgentManager::findAgentForCurrentV8Context() +{ + if (!s_attachedAgentsMap) + return 0; + ASSERT(!s_attachedAgentsMap->isEmpty()); + + WebCore::Frame* frame = WebCore::V8Proxy::retrieveFrameForEnteredContext(); + if (!frame) + return 0; + WebCore::Page* page = frame->page(); + for (AttachedAgentsMap::iterator it = s_attachedAgentsMap->begin(); it != s_attachedAgentsMap->end(); ++it) { + if (it->second->page() == page) + return it->second; + } + return 0; +} + +DebuggerAgentImpl* DebuggerAgentManager::debuggerAgentForHostId(int hostId) +{ + if (!s_attachedAgentsMap) + return 0; + return s_attachedAgentsMap->get(hostId); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/DebuggerAgentManager.h b/WebKit/chromium/src/DebuggerAgentManager.h new file mode 100644 index 0000000..a2e9030 --- /dev/null +++ b/WebKit/chromium/src/DebuggerAgentManager.h @@ -0,0 +1,123 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef DebuggerAgentManager_h +#define DebuggerAgentManager_h + +#include "WebDevToolsAgent.h" +#include <v8-debug.h> +#include <wtf/HashMap.h> +#include <wtf/Noncopyable.h> + +namespace WebCore { +class PageGroupLoadDeferrer; +class String; +} + +namespace WebKit { + +class DebuggerAgentImpl; +class DictionaryValue; +class WebFrameImpl; +class WebViewImpl; + +// There is single v8 instance per render process. Also there may be several +// RenderViews and consequently devtools agents in the process that want to talk +// to the v8 debugger. This class coordinates communication between the debug +// agents and v8 debugger. It will set debug output handler as long as at least +// one debugger agent is attached and remove it when last debugger agent is +// detached. When message is received from debugger it will route it to the +// right debugger agent if there is one otherwise the message will be ignored. +// +// v8 may send a message(e.g. exception event) after which it +// would expect some actions from the handler. If there is no appropriate +// debugger agent to handle such messages the manager will perform the action +// itself, otherwise v8 may hang waiting for the action. +class DebuggerAgentManager : public Noncopyable { +public: + static void debugAttach(DebuggerAgentImpl* debuggerAgent); + static void debugDetach(DebuggerAgentImpl* debuggerAgent); + static void pauseScript(); + static void executeDebuggerCommand(const WebCore::String& command, int callerId); + static void setMessageLoopDispatchHandler(WebDevToolsAgent::MessageLoopDispatchHandler handler); + + // Sets |hostId| as the frame context data. This id is used to filter scripts + // related to the inspected page. + static void setHostId(WebFrameImpl* webframe, int hostId); + + static void onWebViewClosed(WebViewImpl* webview); + + static void onNavigate(); + + class UtilityContextScope : public Noncopyable { + public: + UtilityContextScope() + { + ASSERT(!s_inUtilityContext); + s_inUtilityContext = true; + } + ~UtilityContextScope() + { + if (s_debugBreakDelayed) { + v8::Debug::DebugBreak(); + s_debugBreakDelayed = false; + } + s_inUtilityContext = false; + } + }; + +private: + DebuggerAgentManager(); + ~DebuggerAgentManager(); + + static void debugHostDispatchHandler(); + static void onV8DebugMessage(const v8::Debug::Message& message); + static void sendCommandToV8(const WebCore::String& cmd, + v8::Debug::ClientData* data); + static void sendContinueCommandToV8(); + + static DebuggerAgentImpl* findAgentForCurrentV8Context(); + static DebuggerAgentImpl* debuggerAgentForHostId(int hostId); + + typedef HashMap<int, DebuggerAgentImpl*> AttachedAgentsMap; + static AttachedAgentsMap* s_attachedAgentsMap; + + static WebDevToolsAgent::MessageLoopDispatchHandler s_messageLoopDispatchHandler; + static bool s_inHostDispatchHandler; + typedef HashMap<WebViewImpl*, WebCore::PageGroupLoadDeferrer*> DeferrersMap; + static DeferrersMap s_pageDeferrers; + + static bool s_inUtilityContext; + static bool s_debugBreakDelayed; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/DevToolsRPC.h b/WebKit/chromium/src/DevToolsRPC.h new file mode 100644 index 0000000..7176821 --- /dev/null +++ b/WebKit/chromium/src/DevToolsRPC.h @@ -0,0 +1,396 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +// DevTools RPC subsystem is a simple string serialization-based rpc +// implementation. The client is responsible for defining the Rpc-enabled +// interface in terms of its macros: +// +// #define MYAPI_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3) +// METHOD0(Method1) +// METHOD1(Method3, int) +// (snippet above should be multiline macro, add trailing backslashes) +// +// DEFINE_RPC_CLASS(MyApi, MYAPI_STRUCT) +// +// The snippet above will generate three classes: MyApi, MyApiStub and +// MyApiDispatch. +// +// 1. For each method defined in the marco MyApi will have a +// pure virtual function generated, so that MyApi would look like: +// +// class MyApi { +// private: +// MyApi() { } +// ~MyApi() { } +// virtual void method1() = 0; +// virtual void method2( +// int param1, +// const String& param2, +// const Value& param3) = 0; +// virtual void method3(int param1) = 0; +// }; +// +// 2. MyApiStub will implement MyApi interface and would serialize all calls +// into the string-based calls of the underlying transport: +// +// DevToolsRPC::Delegate* transport; +// myApi = new MyApiStub(transport); +// myApi->method1(); +// myApi->method3(2); +// +// 3. MyApiDelegate is capable of dispatching the calls and convert them to the +// calls to the underlying MyApi methods: +// +// MyApi* realObject; +// MyApiDispatch::dispatch(realObject, rawStringCallGeneratedByStub); +// +// will make corresponding calls to the real object. + +#ifndef DevToolsRPC_h +#define DevToolsRPC_h + +#include "PlatformString.h" +#include "Vector.h" +#include "WebDevToolsMessageData.h" + +#include <wtf/Noncopyable.h> + +namespace WebCore { +class String; +} + +using WebCore::String; +using WTF::Vector; + +namespace WebKit { + +/////////////////////////////////////////////////////// +// RPC dispatch macro + +template<typename T> +struct RpcTypeTrait { + typedef T ApiType; +}; + +template<> +struct RpcTypeTrait<bool> { + typedef bool ApiType; + static bool parse(const WebCore::String& t) + { + return t == "true"; + } + static WebCore::String toString(bool b) + { + return b ? "true" : "false"; + } +}; + +template<> +struct RpcTypeTrait<int> { + typedef int ApiType; + static int parse(const WebCore::String& t) + { + bool success; + int i = t.toIntStrict(&success); + ASSERT(success); + return i; + } + static WebCore::String toString(int i) + { + return WebCore::String::number(i); + } +}; + +template<> +struct RpcTypeTrait<String> { + typedef const String& ApiType; + static String parse(const WebCore::String& t) + { + return t; + } + static WebCore::String toString(const String& t) + { + return t; + } +}; + +/////////////////////////////////////////////////////// +// RPC Api method declarations + +#define TOOLS_RPC_API_METHOD0(Method) \ + virtual void Method() = 0; + +#define TOOLS_RPC_API_METHOD1(Method, T1) \ + virtual void Method(RpcTypeTrait<T1>::ApiType t1) = 0; + +#define TOOLS_RPC_API_METHOD2(Method, T1, T2) \ + virtual void Method(RpcTypeTrait<T1>::ApiType t1, \ + RpcTypeTrait<T2>::ApiType t2) = 0; + +#define TOOLS_RPC_API_METHOD3(Method, T1, T2, T3) \ + virtual void Method(RpcTypeTrait<T1>::ApiType t1, \ + RpcTypeTrait<T2>::ApiType t2, \ + RpcTypeTrait<T3>::ApiType t3) = 0; + +#define TOOLS_RPC_API_METHOD4(Method, T1, T2, T3, T4) \ + virtual void Method(RpcTypeTrait<T1>::ApiType t1, \ + RpcTypeTrait<T2>::ApiType t2, \ + RpcTypeTrait<T3>::ApiType t3, \ + RpcTypeTrait<T4>::ApiType t4) = 0; + +#define TOOLS_RPC_API_METHOD5(Method, T1, T2, T3, T4, T5) \ + virtual void Method(RpcTypeTrait<T1>::ApiType t1, \ + RpcTypeTrait<T2>::ApiType t2, \ + RpcTypeTrait<T3>::ApiType t3, \ + RpcTypeTrait<T4>::ApiType t4, \ + RpcTypeTrait<T5>::ApiType t5) = 0; + +/////////////////////////////////////////////////////// +// RPC stub method implementations + +#define TOOLS_RPC_STUB_METHOD0(Method) \ + virtual void Method() { \ + Vector<String> args; \ + this->sendRpcMessage(m_className, #Method, args); \ + } + +#define TOOLS_RPC_STUB_METHOD1(Method, T1) \ + virtual void Method(RpcTypeTrait<T1>::ApiType t1) { \ + Vector<String> args(1); \ + args[0] = RpcTypeTrait<T1>::toString(t1); \ + this->sendRpcMessage(m_className, #Method, args); \ + } + +#define TOOLS_RPC_STUB_METHOD2(Method, T1, T2) \ + virtual void Method(RpcTypeTrait<T1>::ApiType t1, \ + RpcTypeTrait<T2>::ApiType t2) { \ + Vector<String> args(2); \ + args[0] = RpcTypeTrait<T1>::toString(t1); \ + args[1] = RpcTypeTrait<T2>::toString(t2); \ + this->sendRpcMessage(m_className, #Method, args); \ + } + +#define TOOLS_RPC_STUB_METHOD3(Method, T1, T2, T3) \ + virtual void Method(RpcTypeTrait<T1>::ApiType t1, \ + RpcTypeTrait<T2>::ApiType t2, \ + RpcTypeTrait<T3>::ApiType t3) { \ + Vector<String> args(3); \ + args[0] = RpcTypeTrait<T1>::toString(t1); \ + args[1] = RpcTypeTrait<T2>::toString(t2); \ + args[2] = RpcTypeTrait<T3>::toString(t3); \ + this->sendRpcMessage(m_className, #Method, args); \ + } + +#define TOOLS_RPC_STUB_METHOD4(Method, T1, T2, T3, T4) \ + virtual void Method(RpcTypeTrait<T1>::ApiType t1, \ + RpcTypeTrait<T2>::ApiType t2, \ + RpcTypeTrait<T3>::ApiType t3, \ + RpcTypeTrait<T4>::ApiType t4) { \ + Vector<String> args(4); \ + args[0] = RpcTypeTrait<T1>::toString(t1); \ + args[1] = RpcTypeTrait<T2>::toString(t2); \ + args[2] = RpcTypeTrait<T3>::toString(t3); \ + args[3] = RpcTypeTrait<T4>::toString(t4); \ + this->sendRpcMessage(m_className, #Method, args); \ + } + +#define TOOLS_RPC_STUB_METHOD5(Method, T1, T2, T3, T4, T5) \ + virtual void Method(RpcTypeTrait<T1>::ApiType t1, \ + RpcTypeTrait<T2>::ApiType t2, \ + RpcTypeTrait<T3>::ApiType t3, \ + RpcTypeTrait<T4>::ApiType t4, \ + RpcTypeTrait<T5>::ApiType t5) { \ + Vector<String> args(5); \ + args[0] = RpcTypeTrait<T1>::toString(t1); \ + args[1] = RpcTypeTrait<T2>::toString(t2); \ + args[2] = RpcTypeTrait<T3>::toString(t3); \ + args[3] = RpcTypeTrait<T4>::toString(t4); \ + args[4] = RpcTypeTrait<T5>::toString(t5); \ + this->sendRpcMessage(m_className, #Method, args); \ + } + +/////////////////////////////////////////////////////// +// RPC dispatch method implementations + +#define TOOLS_RPC_DISPATCH0(Method) \ +if (methodName == #Method) { \ + delegate->Method(); \ + return true; \ +} + +#define TOOLS_RPC_DISPATCH1(Method, T1) \ +if (methodName == #Method) { \ + delegate->Method(RpcTypeTrait<T1>::parse(args[0])); \ + return true; \ +} + +#define TOOLS_RPC_DISPATCH2(Method, T1, T2) \ +if (methodName == #Method) { \ + delegate->Method( \ + RpcTypeTrait<T1>::parse(args[0]), \ + RpcTypeTrait<T2>::parse(args[1]) \ + ); \ + return true; \ +} + +#define TOOLS_RPC_DISPATCH3(Method, T1, T2, T3) \ +if (methodName == #Method) { \ + delegate->Method( \ + RpcTypeTrait<T1>::parse(args[0]), \ + RpcTypeTrait<T2>::parse(args[1]), \ + RpcTypeTrait<T3>::parse(args[2]) \ + ); \ + return true; \ +} + +#define TOOLS_RPC_DISPATCH4(Method, T1, T2, T3, T4) \ +if (methodName == #Method) { \ + delegate->Method( \ + RpcTypeTrait<T1>::parse(args[0]), \ + RpcTypeTrait<T2>::parse(args[1]), \ + RpcTypeTrait<T3>::parse(args[2]), \ + RpcTypeTrait<T4>::parse(args[3]) \ + ); \ + return true; \ +} + +#define TOOLS_RPC_DISPATCH5(Method, T1, T2, T3, T4, T5) \ +if (methodName == #Method) { \ + delegate->Method( \ + RpcTypeTrait<T1>::parse(args[0]), \ + RpcTypeTrait<T2>::parse(args[1]), \ + RpcTypeTrait<T3>::parse(args[2]), \ + RpcTypeTrait<T4>::parse(args[3]), \ + RpcTypeTrait<T5>::parse(args[4]) \ + ); \ + return true; \ +} + +#define TOOLS_END_RPC_DISPATCH() \ +} + +// This macro defines three classes: Class with the Api, ClassStub that is +// serializing method calls and ClassDispatch that is capable of dispatching +// the serialized message into its delegate. +#define DEFINE_RPC_CLASS(Class, STRUCT) \ +class Class : public Noncopyable {\ +public: \ + Class() \ + { \ + m_className = #Class; \ + } \ + virtual ~Class() { } \ + \ + STRUCT( \ + TOOLS_RPC_API_METHOD0, \ + TOOLS_RPC_API_METHOD1, \ + TOOLS_RPC_API_METHOD2, \ + TOOLS_RPC_API_METHOD3, \ + TOOLS_RPC_API_METHOD4, \ + TOOLS_RPC_API_METHOD5) \ + WebCore::String m_className; \ +}; \ +\ +class Class##Stub \ + : public Class \ + , public DevToolsRPC { \ +public: \ + explicit Class##Stub(Delegate* delegate) : DevToolsRPC(delegate) { } \ + virtual ~Class##Stub() { } \ + typedef Class CLASS; \ + STRUCT( \ + TOOLS_RPC_STUB_METHOD0, \ + TOOLS_RPC_STUB_METHOD1, \ + TOOLS_RPC_STUB_METHOD2, \ + TOOLS_RPC_STUB_METHOD3, \ + TOOLS_RPC_STUB_METHOD4, \ + TOOLS_RPC_STUB_METHOD5) \ +}; \ +\ +class Class##Dispatch : public Noncopyable { \ +public: \ + Class##Dispatch() { } \ + virtual ~Class##Dispatch() { } \ + \ + static bool dispatch(Class* delegate, \ + const WebKit::WebDevToolsMessageData& data) { \ + String className = data.className; \ + if (className != #Class) \ + return false; \ + String methodName = data.methodName; \ + Vector<String> args; \ + for (size_t i = 0; i < data.arguments.size(); i++) \ + args.append(data.arguments[i]); \ + typedef Class CLASS; \ + STRUCT( \ + TOOLS_RPC_DISPATCH0, \ + TOOLS_RPC_DISPATCH1, \ + TOOLS_RPC_DISPATCH2, \ + TOOLS_RPC_DISPATCH3, \ + TOOLS_RPC_DISPATCH4, \ + TOOLS_RPC_DISPATCH5) \ + return false; \ + } \ +}; + +/////////////////////////////////////////////////////// +// RPC base class +class DevToolsRPC { +public: + class Delegate { + public: + Delegate() { } + virtual ~Delegate() { } + virtual void sendRpcMessage(const WebKit::WebDevToolsMessageData& data) = 0; + }; + + explicit DevToolsRPC(Delegate* delegate) : m_delegate(delegate) { } + virtual ~DevToolsRPC() { }; + +protected: + void sendRpcMessage(const String& className, + const String& methodName, + const Vector<String>& args) { + WebKit::WebVector<WebKit::WebString> webArgs(args.size()); + for (size_t i = 0; i < args.size(); i++) + webArgs[i] = args[i]; + WebKit::WebDevToolsMessageData data; + data.className = className; + data.methodName = methodName; + data.arguments.swap(webArgs); + this->m_delegate->sendRpcMessage(data); + } + + Delegate* m_delegate; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/DevToolsRPCJS.h b/WebKit/chromium/src/DevToolsRPCJS.h new file mode 100644 index 0000000..8ae279f --- /dev/null +++ b/WebKit/chromium/src/DevToolsRPCJS.h @@ -0,0 +1,147 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +// Additional set of macros for the JS RPC. + +#ifndef DevToolsRPCJS_h +#define DevToolsRPCJS_h + +// Do not remove this one although it is not used. +#include "BoundObject.h" +#include "DevToolsRPC.h" +#include "WebFrame.h" +#include <wtf/Noncopyable.h> +#include <wtf/OwnPtr.h> + +namespace WebKit { + +/////////////////////////////////////////////////////// +// JS RPC binds and stubs + +#define TOOLS_RPC_JS_BIND_METHOD0(Method) \ + boundObj.addProtoFunction(#Method, OCLASS::js##Method); + +#define TOOLS_RPC_JS_BIND_METHOD1(Method, T1) \ + boundObj.addProtoFunction(#Method, OCLASS::js##Method); + +#define TOOLS_RPC_JS_BIND_METHOD2(Method, T1, T2) \ + boundObj.addProtoFunction(#Method, OCLASS::js##Method); + +#define TOOLS_RPC_JS_BIND_METHOD3(Method, T1, T2, T3) \ + boundObj.addProtoFunction(#Method, OCLASS::js##Method); + +#define TOOLS_RPC_JS_BIND_METHOD4(Method, T1, T2, T3, T4) \ + boundObj.addProtoFunction(#Method, OCLASS::js##Method); + +#define TOOLS_RPC_JS_BIND_METHOD5(Method, T1, T2, T3, T4, T5) \ + boundObj.addProtoFunction(#Method, OCLASS::js##Method); + +#define TOOLS_RPC_JS_STUB_METHOD0(Method) \ + static v8::Handle<v8::Value> js##Method(const v8::Arguments& args) { \ + sendRpcMessageFromJS(#Method, args, 0); \ + return v8::Undefined(); \ + } + +#define TOOLS_RPC_JS_STUB_METHOD1(Method, T1) \ + static v8::Handle<v8::Value> js##Method(const v8::Arguments& args) { \ + sendRpcMessageFromJS(#Method, args, 1); \ + return v8::Undefined(); \ + } + +#define TOOLS_RPC_JS_STUB_METHOD2(Method, T1, T2) \ + static v8::Handle<v8::Value> js##Method(const v8::Arguments& args) { \ + sendRpcMessageFromJS(#Method, args, 2); \ + return v8::Undefined(); \ + } + +#define TOOLS_RPC_JS_STUB_METHOD3(Method, T1, T2, T3) \ + static v8::Handle<v8::Value> js##Method(const v8::Arguments& args) { \ + sendRpcMessageFromJS(#Method, args, 3); \ + return v8::Undefined(); \ + } + +#define TOOLS_RPC_JS_STUB_METHOD4(Method, T1, T2, T3, T4) \ + static v8::Handle<v8::Value> js##Method(const v8::Arguments& args) { \ + sendRpcMessageFromJS(#Method, args, 4); \ + return v8::Undefined(); \ + } + +#define TOOLS_RPC_JS_STUB_METHOD5(Method, T1, T2, T3, T4, T5) \ + static v8::Handle<v8::Value> js##Method(const v8::Arguments& args) { \ + sendRpcMessageFromJS(#Method, args, 5); \ + return v8::Undefined(); \ + } + +/////////////////////////////////////////////////////// +// JS RPC main obj macro + +#define DEFINE_RPC_JS_BOUND_OBJ(Class, STRUCT, DClass, DELEGATE_STRUCT) \ +class JS##Class##BoundObj : public Class##Stub { \ +public: \ + JS##Class##BoundObj(Delegate* rpcDelegate, \ + v8::Handle<v8::Context> context, \ + const char* classname) \ + : Class##Stub(rpcDelegate) { \ + BoundObject boundObj(context, this, classname); \ + STRUCT( \ + TOOLS_RPC_JS_BIND_METHOD0, \ + TOOLS_RPC_JS_BIND_METHOD1, \ + TOOLS_RPC_JS_BIND_METHOD2, \ + TOOLS_RPC_JS_BIND_METHOD3, \ + TOOLS_RPC_JS_BIND_METHOD4, \ + TOOLS_RPC_JS_BIND_METHOD5) \ + boundObj.build(); \ + } \ + virtual ~JS##Class##BoundObj() { } \ + typedef JS##Class##BoundObj OCLASS; \ + STRUCT( \ + TOOLS_RPC_JS_STUB_METHOD0, \ + TOOLS_RPC_JS_STUB_METHOD1, \ + TOOLS_RPC_JS_STUB_METHOD2, \ + TOOLS_RPC_JS_STUB_METHOD3, \ + TOOLS_RPC_JS_STUB_METHOD4, \ + TOOLS_RPC_JS_STUB_METHOD5) \ +private: \ + static void sendRpcMessageFromJS(const char* method, \ + const v8::Arguments& jsArguments, \ + size_t argsCount) \ + { \ + Vector<String> args(argsCount); \ + for (size_t i = 0; i < argsCount; i++) \ + args[i] = WebCore::toWebCoreStringWithNullCheck(jsArguments[i]); \ + void* selfPtr = v8::External::Cast(*jsArguments.Data())->Value(); \ + JS##Class##BoundObj* self = static_cast<JS##Class##BoundObj*>(selfPtr); \ + self->sendRpcMessage(#Class, method, args); \ + } \ +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/DragClientImpl.cpp b/WebKit/chromium/src/DragClientImpl.cpp new file mode 100644 index 0000000..671e7ca --- /dev/null +++ b/WebKit/chromium/src/DragClientImpl.cpp @@ -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. + */ + +#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 = clipboard->sourceOperation(); + + 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..d5bddc5 --- /dev/null +++ b/WebKit/chromium/src/EditorClientImpl.cpp @@ -0,0 +1,922 @@ +/* + * Copyright (C) 2006, 2007 Apple, Inc. All rights reserved. + * Copyright (C) 2010 Google, Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 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 OS(WINDOWS) + 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 OS(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 OS(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 OS(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 OS(DARWIN) + { VKEY_LEFT, CommandKey, "MoveToBeginningOfLine" }, + { VKEY_LEFT, CommandKey | ShiftKey, + "MoveToBeginningOfLineAndModifySelection" }, +#endif +#if OS(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 OS(DARWIN) + { VKEY_DOWN, CommandKey, "MoveToEndOfDocument" }, + { VKEY_DOWN, CommandKey | ShiftKey, + "MoveToEndOfDocumentAndModifySelection" }, +#else + { VKEY_END, CtrlKey, "MoveToEndOfDocument" }, + { VKEY_END, CtrlKey | ShiftKey, + "MoveToEndOfDocumentAndModifySelection" }, +#endif +#if OS(DARWIN) + { VKEY_RIGHT, CommandKey, "MoveToEndOfLine" }, + { VKEY_RIGHT, CommandKey | ShiftKey, + "MoveToEndOfLineAndModifySelection" }, +#endif + { VKEY_BACK, 0, "DeleteBackward" }, + { VKEY_BACK, ShiftKey, "DeleteBackward" }, + { VKEY_DELETE, 0, "DeleteForward" }, +#if OS(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 !OS(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 !OS(WINDOWS) + // 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 OS(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->hideSuggestionsPopup(); + + 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->hideSuggestionsPopup(); + 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/EventListenerWrapper.cpp b/WebKit/chromium/src/EventListenerWrapper.cpp new file mode 100644 index 0000000..f2d2979 --- /dev/null +++ b/WebKit/chromium/src/EventListenerWrapper.cpp @@ -0,0 +1,72 @@ +/*
+ * Copyright (C) 2010 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "EventListenerWrapper.h"
+
+#include "Event.h"
+#include "EventListener.h"
+
+#include "WebEvent.h"
+#include "WebEventListener.h"
+
+namespace WebKit {
+
+EventListenerWrapper::EventListenerWrapper(WebEventListener* webEventListener)
+ : EventListener(EventListener::JSEventListenerType)
+ , m_webEventListener(webEventListener)
+{
+}
+
+EventListenerWrapper::~EventListenerWrapper()
+{
+ if (m_webEventListener)
+ m_webEventListener->notifyEventListenerDeleted(this);
+}
+
+bool EventListenerWrapper::operator==(const EventListener& listener)
+{
+ return this == &listener;
+}
+
+void EventListenerWrapper::handleEvent(ScriptExecutionContext* context, Event* event)
+{
+ if (!m_webEventListener)
+ return;
+ WebEvent webEvent(event);
+ m_webEventListener->handleEvent(webEvent);
+}
+
+void EventListenerWrapper::webEventListenerDeleted()
+{
+ m_webEventListener = 0;
+}
+
+} // namespace WebKit
diff --git a/WebKit/chromium/src/EventListenerWrapper.h b/WebKit/chromium/src/EventListenerWrapper.h new file mode 100644 index 0000000..2a0cbbb --- /dev/null +++ b/WebKit/chromium/src/EventListenerWrapper.h @@ -0,0 +1,62 @@ +/*
+ * Copyright (C) 2010 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef EventListenerWrapper_h
+#define EventListenerWrapper_h
+
+#include "EventListener.h"
+
+namespace WebCore {
+class ScriptExecutionContext;
+}
+
+using namespace WebCore;
+
+namespace WebKit {
+
+class WebEventListener;
+
+class EventListenerWrapper : public EventListener {
+public:
+ EventListenerWrapper(WebEventListener*);
+ ~EventListenerWrapper();
+
+ virtual bool operator==(const EventListener&);
+ virtual void handleEvent(ScriptExecutionContext*, Event*);
+
+ void webEventListenerDeleted();
+
+private:
+ WebEventListener* m_webEventListener;
+};
+
+} // namespace WebKit
+
+#endif
diff --git a/WebKit/chromium/src/FrameLoaderClientImpl.cpp b/WebKit/chromium/src/FrameLoaderClientImpl.cpp new file mode 100644 index 0000000..b984308 --- /dev/null +++ b/WebKit/chromium/src/FrameLoaderClientImpl.cpp @@ -0,0 +1,1485 @@ +/* + * 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::allowPlugins(bool enabledPerSettings) +{ + if (m_webFrame->client()) + return m_webFrame->client()->allowPlugins(m_webFrame, enabledPerSettings); + + return enabledPerSettings; +} + +bool FrameLoaderClientImpl::allowImages(bool enabledPerSettings) +{ + if (m_webFrame->client()) + return m_webFrame->client()->allowImages(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 !OS(WINDOWS) + // 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..901600c --- /dev/null +++ b/WebKit/chromium/src/FrameLoaderClientImpl.h @@ -0,0 +1,242 @@ +/* + * 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 evaluateInIsolatedWorld). + // 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); + virtual bool allowPlugins(bool enabledPerSettings); + virtual bool allowImages(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..83574da --- /dev/null +++ b/WebKit/chromium/src/GraphicsContext3D.cpp @@ -0,0 +1,2218 @@ +/* + * 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 OS(WINDOWS) +#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 OS(DARWIN) +#define USE_TEXTURE_RECTANGLE_FOR_FRAMEBUFFER +#endif + +#if OS(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(GraphicsContext3D::Attributes attrs); + ~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 bindFramebuffer(unsigned long target, + WebGLFramebuffer* framebuffer); + 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(); + GraphicsContext3D::Attributes getContextAttributes(); + 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: + GraphicsContext3D::Attributes m_attrs; + + unsigned int m_texture; + unsigned int m_fbo; + unsigned int m_depthBuffer; + unsigned int m_cachedWidth, m_cachedHeight; + + // For tracking which FBO is bound + unsigned int m_boundFBO; + +#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 + + static bool s_initializedGLEW; +#if OS(WINDOWS) + HWND m_canvasWindow; + HDC m_canvasDC; + HGLRC m_contextObj; +#elif PLATFORM(CG) + CGLPBufferObj m_pbuffer; + CGLContextObj m_contextObj; + unsigned char* m_renderOutput; +#elif OS(LINUX) + 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 + class GLConnection { + public: + ~GLConnection(); + + static GLConnection* create(); + + GLXFBConfig* chooseFBConfig(int screen, const int *attrib_list, int *nelements) + { + return m_glXChooseFBConfig(m_display, screen, attrib_list, nelements); + } + + GLXContext createNewContext(GLXFBConfig config, int renderType, GLXContext shareList, Bool direct) + { + return m_glXCreateNewContext(m_display, config, renderType, shareList, direct); + } + + GLXPbuffer createPbuffer(GLXFBConfig config, const int *attribList) + { + return m_glXCreatePbuffer(m_display, config, attribList); + } + + void destroyPbuffer(GLXPbuffer pbuf) + { + m_glXDestroyPbuffer(m_display, pbuf); + } + + Bool makeCurrent(GLXDrawable drawable, GLXContext ctx) + { + return m_glXMakeCurrent(m_display, drawable, ctx); + } + + void destroyContext(GLXContext ctx) + { + m_glXDestroyContext(m_display, ctx); + } + + GLXContext getCurrentContext() + { + return m_glXGetCurrentContext(); + } + + private: + Display* m_display; + 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; + + GLConnection(Display* display, + void* libGL, + PFNGLXCHOOSEFBCONFIGPROC chooseFBConfig, + PFNGLXCREATENEWCONTEXTPROC createNewContext, + PFNGLXCREATEPBUFFERPROC createPbuffer, + PFNGLXDESTROYPBUFFERPROC destroyPbuffer, + PFNGLXMAKECURRENTPROC makeCurrent, + PFNGLXDESTROYCONTEXTPROC destroyContext, + PFNGLXGETCURRENTCONTEXTPROC getCurrentContext) + : m_libGL(libGL) + , m_display(display) + , m_glXChooseFBConfig(chooseFBConfig) + , m_glXCreateNewContext(createNewContext) + , m_glXCreatePbuffer(createPbuffer) + , m_glXDestroyPbuffer(destroyPbuffer) + , m_glXMakeCurrent(makeCurrent) + , m_glXDestroyContext(destroyContext) + , m_glXGetCurrentContext(getCurrentContext) + { + } + }; + + static GLConnection* s_gl; +#else + #error Must port GraphicsContext3D to your platform +#endif +}; + +bool GraphicsContext3DInternal::s_initializedGLEW = false; + +#if OS(LINUX) +GraphicsContext3DInternal::GLConnection* GraphicsContext3DInternal::s_gl = 0; + +GraphicsContext3DInternal::GLConnection* GraphicsContext3DInternal::GLConnection::create() +{ + Display* dpy = XOpenDisplay(0); + if (!dpy) { + printf("GraphicsContext3D: error opening X display\n"); + return 0; + } + + // 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. + void* libGL = dlopen("libGL.so.1", RTLD_LAZY | RTLD_GLOBAL); + if (!libGL) { + XCloseDisplay(dpy); + printf("GraphicsContext3D: error opening libGL.so.1: %s\n", dlerror()); + return 0; + } + + PFNGLXCHOOSEFBCONFIGPROC chooseFBConfig = (PFNGLXCHOOSEFBCONFIGPROC) dlsym(libGL, "glXChooseFBConfig"); + PFNGLXCREATENEWCONTEXTPROC createNewContext = (PFNGLXCREATENEWCONTEXTPROC) dlsym(libGL, "glXCreateNewContext"); + PFNGLXCREATEPBUFFERPROC createPbuffer = (PFNGLXCREATEPBUFFERPROC) dlsym(libGL, "glXCreatePbuffer"); + PFNGLXDESTROYPBUFFERPROC destroyPbuffer = (PFNGLXDESTROYPBUFFERPROC) dlsym(libGL, "glXDestroyPbuffer"); + PFNGLXMAKECURRENTPROC makeCurrent = (PFNGLXMAKECURRENTPROC) dlsym(libGL, "glXMakeCurrent"); + PFNGLXDESTROYCONTEXTPROC destroyContext = (PFNGLXDESTROYCONTEXTPROC) dlsym(libGL, "glXDestroyContext"); + PFNGLXGETCURRENTCONTEXTPROC getCurrentContext = (PFNGLXGETCURRENTCONTEXTPROC) dlsym(libGL, "glXGetCurrentContext"); + if (!chooseFBConfig || !createNewContext || !createPbuffer + || !destroyPbuffer || !makeCurrent || !destroyContext + || !getCurrentContext) { + XCloseDisplay(dpy); + dlclose(libGL); + printf("GraphicsContext3D: error looking up bootstrapping entry points\n"); + return 0; + } + return new GLConnection(dpy, + libGL, + chooseFBConfig, + createNewContext, + createPbuffer, + destroyPbuffer, + makeCurrent, + destroyContext, + getCurrentContext); +} + +GraphicsContext3DInternal::GLConnection::~GLConnection() +{ + XCloseDisplay(m_display); + dlclose(m_libGL); +} + +#endif // OS(LINUX) + +GraphicsContext3DInternal::VertexAttribPointerState::VertexAttribPointerState() + : enabled(false) + , buffer(0) + , indx(0) + , size(0) + , type(0) + , normalized(false) + , stride(0) + , offset(0) +{ +} + +GraphicsContext3DInternal::GraphicsContext3DInternal(GraphicsContext3D::Attributes attrs) + : m_attrs(attrs) + , m_texture(0) + , m_fbo(0) + , m_depthBuffer(0) + , m_boundFBO(0) +#ifdef FLIP_FRAMEBUFFER_VERTICALLY + , m_scanline(0) +#endif + , m_boundArrayBuffer(0) +#if PLATFORM(SKIA) + , m_resizingBitmap(0) +#endif +#if OS(WINDOWS) + , m_canvasWindow(0) + , m_canvasDC(0) + , m_contextObj(0) +#elif PLATFORM(CG) + , m_pbuffer(0) + , m_contextObj(0) + , m_renderOutput(0) +#elif OS(LINUX) + , m_contextObj(0) + , m_pbuffer(0) +#else +#error Must port to your platform +#endif +{ + // FIXME: we need to take into account the user's requested + // context creation attributes, in particular stencil and + // antialias, and determine which could and could not be honored + // based on the capabilities of the OpenGL implementation. + m_attrs.alpha = true; + m_attrs.depth = true; + m_attrs.stencil = false; + m_attrs.antialias = false; + m_attrs.premultipliedAlpha = true; + +#if OS(WINDOWS) + 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 OS(LINUX) + if (!s_gl) { + s_gl = GLConnection::create(); + if (!s_gl) + return; + } + + int configAttrs[] = { + GLX_DRAWABLE_TYPE, + GLX_PBUFFER_BIT, + GLX_RENDER_TYPE, + GLX_RGBA_BIT, + GLX_DOUBLEBUFFER, + 0, + 0 + }; + int nelements = 0; + GLXFBConfig* config = s_gl->chooseFBConfig(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 = s_gl->createNewContext(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 = s_gl->createPbuffer(config[0], pbufferAttrs); + XFree(config); + if (!pbuffer) { + printf("GraphicsContext3D: glxCreatePbuffer failed\n"); + return; + } + if (!s_gl->makeCurrent(pbuffer, context)) { + printf("GraphicsContext3D: glXMakeCurrent failed\n"); + return; + } + m_contextObj = context; + m_pbuffer = pbuffer; +#else +#error Must port to your platform +#endif + + if (!s_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; + } + s_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 OS(WINDOWS) + 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_renderOutput) + delete[] m_renderOutput; +#elif OS(LINUX) + s_gl->makeCurrent(0, 0); + s_gl->destroyContext(m_contextObj); + s_gl->destroyPbuffer(m_pbuffer); +#else +#error Must port to your platform +#endif + m_contextObj = 0; +} + +bool GraphicsContext3DInternal::makeContextCurrent() +{ +#if OS(WINDOWS) + 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 OS(LINUX) + if (s_gl->getCurrentContext() != m_contextObj) + if (s_gl->makeCurrent(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); + m_boundFBO = 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); + +#if PLATFORM(CG) + // Need to reallocate the client-side backing store. + // FIXME: make this more efficient. + if (m_renderOutput) { + delete[] m_renderOutput; + m_renderOutput = 0; + } + int rowBytes = width * 4; + m_renderOutput = new unsigned char[height * rowBytes]; +#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; + bool mustRestoreFBO = (m_boundFBO != m_fbo); + if (mustRestoreFBO) + glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo); +#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) { + pixels = m_renderOutput; + glReadPixels(0, 0, m_cachedWidth, m_cachedHeight, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, pixels); + } +#else +#error Must port to your platform +#endif + + if (mustRestoreFBO) + glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_boundFBO); + +#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) { + int rowBytes = m_cachedWidth * 4; + CGDataProviderRef dataProvider = CGDataProviderCreateWithData(0, m_renderOutput, rowBytes * m_cachedHeight, 0); + CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB(); + CGImageRef cgImage = CGImageCreate(m_cachedWidth, + m_cachedHeight, + 8, + 32, + rowBytes, + colorSpace, + kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host, + dataProvider, + 0, + false, + kCGRenderingIntentDefault); + // 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); + CGContextSetInterpolationQuality(imageBuffer->context()->platformContext(), + kCGInterpolationNone); + CGContextDrawImage(imageBuffer->context()->platformContext(), + rect, cgImage); + CGImageRelease(cgImage); + CGColorSpaceRelease(colorSpace); + CGDataProviderRelease(dataProvider); + } +#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); +} + +void GraphicsContext3DInternal::bindFramebuffer(unsigned long target, + WebGLFramebuffer* framebuffer) +{ + makeContextCurrent(); + GLuint id = EXTRACT(framebuffer); + if (!id) + id = m_fbo; + glBindFramebufferEXT(target, id); + m_boundFBO = id; +} + +// 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(); +} + +GraphicsContext3D::Attributes GraphicsContext3DInternal::getContextAttributes() +{ + return m_attrs; +} + +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(GraphicsContext3D::Attributes attrs) +{ + PassOwnPtr<GraphicsContext3D> context = new GraphicsContext3D(attrs); + // FIXME: add error checking + return context; +} + +GraphicsContext3D::GraphicsContext3D(GraphicsContext3D::Attributes attrs) + : m_currentWidth(0) + , m_currentHeight(0) + , m_internal(new GraphicsContext3DInternal(attrs)) +{ +} + +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); +} + +void GraphicsContext3D::bindFramebuffer(unsigned long target, WebGLFramebuffer* framebuffer) +{ + m_internal->bindFramebuffer(target, framebuffer); +} + +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); +} + +GraphicsContext3D::Attributes GraphicsContext3D::getContextAttributes() +{ + return m_internal->getContextAttributes(); +} + +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, + void* 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); + return 0; +} + +// 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); + CGContextSetBlendMode(tmpContext, kCGBlendModeCopy); + 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; +} + +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, + void* pixels) +{ + glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); + return 0; +} + +int GraphicsContext3D::texSubImage2D(unsigned target, + unsigned level, + unsigned xoffset, + unsigned yoffset, + Image* image, + 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..4e01848 --- /dev/null +++ b/WebKit/chromium/src/LocalizedStrings.cpp @@ -0,0 +1,317 @@ +/* + * 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 AXMenuListPopupActionVerb() +{ + return String(); +} + +String AXMenuListActionVerb() +{ + return String(); +} + +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..a38b8b5 --- /dev/null +++ b/WebKit/chromium/src/NotificationPresenterImpl.cpp @@ -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. + */ + +#include "config.h" +#include "NotificationPresenterImpl.h" + +#if ENABLE(NOTIFICATIONS) + +#include "Document.h" +#include "Notification.h" +#include "SecurityOrigin.h" + +#include "WebDocument.h" +#include "WebNotification.h" +#include "WebNotificationPermissionCallback.h" +#include "WebNotificationPresenter.h" +#include "WebURL.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(const KURL& url, Document* document) +{ + WebDocument webDocument; + if (document) + webDocument = document; + + int result = m_presenter->checkPermission(url, document ? &webDocument : 0); + 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..8e3799c --- /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(const WebCore::KURL& url, WebCore::Document* document); + 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..aa42a10 --- /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()->toWireString(); + 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::createFromWire(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/ProfilerAgent.h b/WebKit/chromium/src/ProfilerAgent.h new file mode 100644 index 0000000..52337b8 --- /dev/null +++ b/WebKit/chromium/src/ProfilerAgent.h @@ -0,0 +1,61 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ProfilerAgent_h +#define ProfilerAgent_h + +#include "DevToolsRPC.h" + +namespace WebKit { + +// Profiler agent provides API for retrieving profiler data. +// These methods are handled on the IO thread, so profiler can +// operate while a script on a page performs heavy work. +#define PROFILER_AGENT_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3, METHOD4, METHOD5) \ + /* Requests current profiler state. */ \ + METHOD0(getActiveProfilerModules) \ + \ + /* Retrieves portion of profiler log. */ \ + METHOD1(getLogLines, int /* position */) + +DEFINE_RPC_CLASS(ProfilerAgent, PROFILER_AGENT_STRUCT) + +#define PROFILER_AGENT_DELEGATE_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3, METHOD4, METHOD5) \ + /* Response to getActiveProfilerModules. */ \ + METHOD1(didGetActiveProfilerModules, int /* flags */) \ + \ + /* Response to getLogLines. */ \ + METHOD2(didGetLogLines, int /* position */, String /* log */) + +DEFINE_RPC_CLASS(ProfilerAgentDelegate, PROFILER_AGENT_DELEGATE_STRUCT) + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/ProfilerAgentImpl.cpp b/WebKit/chromium/src/ProfilerAgentImpl.cpp new file mode 100644 index 0000000..07570df --- /dev/null +++ b/WebKit/chromium/src/ProfilerAgentImpl.cpp @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "ProfilerAgentImpl.h" + +#include <v8.h> + +namespace WebKit { + +void ProfilerAgentImpl::getActiveProfilerModules() +{ + m_delegate->didGetActiveProfilerModules(v8::V8::GetActiveProfilerModules()); +} + +void ProfilerAgentImpl::getLogLines(int position) +{ + static char buffer[65536]; + const int readSize = v8::V8::GetLogLines(position, buffer, sizeof(buffer) - 1); + buffer[readSize] = '\0'; + position += readSize; + m_delegate->didGetLogLines(position, buffer); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/ProfilerAgentImpl.h b/WebKit/chromium/src/ProfilerAgentImpl.h new file mode 100644 index 0000000..d38f57c --- /dev/null +++ b/WebKit/chromium/src/ProfilerAgentImpl.h @@ -0,0 +1,57 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ProfilerAgentImpl_h +#define ProfilerAgentImpl_h + +#include "ProfilerAgent.h" + +namespace WebKit { + +class ProfilerAgentImpl : public ProfilerAgent { +public: + ProfilerAgentImpl(ProfilerAgentDelegate* delegate) : m_delegate(delegate) { } + virtual ~ProfilerAgentImpl() { } + + // ProfilerAgent implementation. + + // This method is called on IO thread. + virtual void getActiveProfilerModules(); + + // This method is called on IO thread. + virtual void getLogLines(int position); + +private: + ProfilerAgentDelegate* m_delegate; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/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..c803aac --- /dev/null +++ b/WebKit/chromium/src/SharedWorkerRepository.cpp @@ -0,0 +1,234 @@ +/* + * 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 { +public: + SharedWorkerScriptLoader(PassRefPtr<SharedWorker> worker, const KURL& url, const String& name, PassOwnPtr<MessagePortChannel> port, PassOwnPtr<WebSharedWorker> webWorker) + : m_worker(worker) + , m_url(url) + , m_name(name) + , m_webWorker(webWorker) + , m_port(port) + , m_loading(false) + { + } + + ~SharedWorkerScriptLoader(); + void load(); + static void stopAllLoadersForContext(ScriptExecutionContext*); + +private: + // WorkerScriptLoaderClient callback + virtual void notifyFinished(); + + virtual void connected(); + + const ScriptExecutionContext* loadingContext() { return m_worker->scriptExecutionContext(); } + + void sendConnect(); + + RefPtr<SharedWorker> m_worker; + KURL m_url; + String m_name; + OwnPtr<WebSharedWorker> m_webWorker; + OwnPtr<MessagePortChannel> m_port; + WorkerScriptLoader m_scriptLoader; + bool m_loading; +}; + +static Vector<SharedWorkerScriptLoader*>& pendingLoaders() +{ + AtomicallyInitializedStatic(Vector<SharedWorkerScriptLoader*>&, loaders = *new Vector<SharedWorkerScriptLoader*>); + return loaders; +} + +void SharedWorkerScriptLoader::stopAllLoadersForContext(ScriptExecutionContext* context) +{ + // Walk our list of pending loaders and shutdown any that belong to this context. + Vector<SharedWorkerScriptLoader*>& loaders = pendingLoaders(); + for (unsigned i = 0; i < loaders.size(); ) { + SharedWorkerScriptLoader* loader = loaders[i]; + if (context == loader->loadingContext()) { + loaders.remove(i); + delete loader; + } else + i++; + } +} + +SharedWorkerScriptLoader::~SharedWorkerScriptLoader() +{ + if (m_loading) + m_worker->unsetPendingActivity(m_worker.get()); +} + +void SharedWorkerScriptLoader::load() +{ + ASSERT(!m_loading); + // 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); + // Keep the worker + JS wrapper alive until the resource load is complete in case we need to dispatch an error event. + m_worker->setPendingActivity(m_worker.get()); + m_loading = true; + } +} + +// 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::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)); + + // Stop the creation of any pending SharedWorkers for this context. + // FIXME: Need a way to invoke this for WorkerContexts as well when we support for nested workers. + SharedWorkerScriptLoader::stopAllLoadersForContext(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..c9185fe --- /dev/null +++ b/WebKit/chromium/src/StorageAreaProxy.cpp @@ -0,0 +1,146 @@ +/* + * Copyright (C) 2009 Google Inc. All Rights Reserved. + * (C) 2008 Apple 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 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 "DOMWindow.h" +#include "Document.h" +#include "EventNames.h" +#include "ExceptionCode.h" +#include "Frame.h" +#include "Page.h" +#include "PageGroup.h" +#include "SecurityOrigin.h" +#include "StorageAreaImpl.h" +#include "StorageEvent.h" + +#include "WebStorageArea.h" +#include "WebString.h" +#include "WebURL.h" + +namespace WebCore { + +StorageAreaProxy::StorageAreaProxy(WebKit::WebStorageArea* storageArea, StorageType storageType) + : m_storageArea(storageArea) + , m_storageType(storageType) +{ +} + +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); +} + +String StorageAreaProxy::setItem(const String& key, const String& value, ExceptionCode& ec, Frame* frame) +{ + bool quotaException = false; + WebKit::WebString oldValue; + m_storageArea->setItem(key, value, frame->document()->url(), quotaException, oldValue); + ec = quotaException ? QUOTA_EXCEEDED_ERR : 0; + String oldValueString = oldValue; + if (oldValueString != value) + storageEvent(key, oldValue, value, m_storageType, frame->document()->securityOrigin(), frame); + return oldValue; +} + +String StorageAreaProxy::removeItem(const String& key, Frame* frame) +{ + WebKit::WebString oldValue; + m_storageArea->removeItem(key, frame->document()->url(), oldValue); + if (!oldValue.isNull()) + storageEvent(key, oldValue, String(), m_storageType, frame->document()->securityOrigin(), frame); + return oldValue; +} + +bool StorageAreaProxy::clear(Frame* frame) +{ + bool clearedSomething; + m_storageArea->clear(frame->document()->url(), clearedSomething); + if (clearedSomething) + storageEvent(String(), String(), String(), m_storageType, frame->document()->securityOrigin(), frame); + return clearedSomething; +} + +bool StorageAreaProxy::contains(const String& key) const +{ + return !getItem(key).isNull(); +} + +// Copied from WebCore/storage/StorageEventDispatcher.cpp out of necessity. It's probably best to keep it current. +void StorageAreaProxy::storageEvent(const String& key, const String& oldValue, const String& newValue, StorageType storageType, SecurityOrigin* securityOrigin, Frame* sourceFrame) +{ + Page* page = sourceFrame->page(); + if (!page) + 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; + if (storageType == SessionStorage) { + // Send events only to our page. + for (Frame* frame = page->mainFrame(); frame; frame = frame->tree()->traverseNext()) { + if (sourceFrame != frame && frame->document()->securityOrigin()->equal(securityOrigin)) + frames.append(frame); + } + + for (unsigned i = 0; i < frames.size(); ++i) + frames[i]->document()->enqueueStorageEvent(StorageEvent::create(eventNames().storageEvent, key, oldValue, newValue, sourceFrame->document()->url(), frames[i]->domWindow()->sessionStorage())); + } else { + // Send events to every page. + const HashSet<Page*>& pages = page->group().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 (sourceFrame != frame && frame->document()->securityOrigin()->equal(securityOrigin)) + frames.append(frame); + } + } + + for (unsigned i = 0; i < frames.size(); ++i) + frames[i]->document()->enqueueStorageEvent(StorageEvent::create(eventNames().storageEvent, key, oldValue, newValue, sourceFrame->document()->url(), frames[i]->domWindow()->localStorage())); + } +} + +} // 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..b169828 --- /dev/null +++ b/WebKit/chromium/src/StorageAreaProxy.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: + * 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 Frame; +class SecurityOrigin; + +class StorageAreaProxy : public StorageArea { +public: + StorageAreaProxy(WebKit::WebStorageArea*, StorageType); + 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 String setItem(const String& key, const String& value, ExceptionCode& ec, Frame* sourceFrame); + virtual String removeItem(const String& key, Frame* sourceFrame); + virtual bool clear(Frame* sourceFrame); + virtual bool contains(const String& key) const; + +private: + void storageEvent(const String& key, const String& oldValue, const String& newValue, StorageType, SecurityOrigin*, Frame* sourceFrame); + + OwnPtr<WebKit::WebStorageArea> m_storageArea; + StorageType m_storageType; +}; + +} // 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..1be1967 --- /dev/null +++ b/WebKit/chromium/src/StorageNamespaceProxy.cpp @@ -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: + * 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 "Chrome.h" +#include "ChromeClientImpl.h" +#include "Page.h" +#include "SecurityOrigin.h" +#include "StorageAreaProxy.h" +#include "WebKit.h" +#include "WebKitClient.h" +#include "WebStorageNamespace.h" +#include "WebString.h" +#include "WebViewClient.h" +#include "WebViewImpl.h" + +namespace WebCore { + +PassRefPtr<StorageNamespace> StorageNamespace::localStorageNamespace(const String& path, unsigned quota) +{ + return adoptRef(new StorageNamespaceProxy(WebKit::webKitClient()->createLocalStorageNamespace(path, quota), LocalStorage)); +} + +PassRefPtr<StorageNamespace> StorageNamespace::sessionStorageNamespace(Page* page) +{ + WebKit::ChromeClientImpl* chromeClientImpl = static_cast<WebKit::ChromeClientImpl*>(page->chrome()->client()); + WebKit::WebViewClient* webViewClient = chromeClientImpl->webView()->client(); + return adoptRef(new StorageNamespaceProxy(webViewClient->createSessionStorageNamespace(), SessionStorage)); +} + +StorageNamespaceProxy::StorageNamespaceProxy(WebKit::WebStorageNamespace* storageNamespace, StorageType storageType) + : m_storageNamespace(storageNamespace) + , m_storageType(storageType) +{ +} + +StorageNamespaceProxy::~StorageNamespaceProxy() +{ +} + +PassRefPtr<StorageNamespace> StorageNamespaceProxy::copy() +{ + ASSERT(m_storageType == SessionStorage); + // The WebViewClient knows what its session storage namespace id is but we + // do not. Returning 0 here causes it to be fetched (via the WebViewClient) + // on its next use. Note that it is WebViewClient::createView's + // responsibility to clone the session storage namespace id and that the + // only time copy() is called is directly after the createView call...which + // is why all of this is safe. + return 0; +} + +PassRefPtr<StorageArea> StorageNamespaceProxy::storageArea(PassRefPtr<SecurityOrigin> origin) +{ + return adoptRef(new StorageAreaProxy(m_storageNamespace->createStorageArea(origin->toString()), m_storageType)); +} + +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..28d7a23 --- /dev/null +++ b/WebKit/chromium/src/StorageNamespaceProxy.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: + * 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 "StorageArea.h" +#include "StorageNamespace.h" + +namespace WebKit { class WebStorageNamespace; } + +namespace WebCore { + +class StorageNamespaceProxy : public StorageNamespace { +public: + StorageNamespaceProxy(WebKit::WebStorageNamespace*, StorageType); + virtual ~StorageNamespaceProxy(); + virtual PassRefPtr<StorageArea> storageArea(PassRefPtr<SecurityOrigin>); + virtual PassRefPtr<StorageNamespace> copy(); + virtual void close(); + virtual void unlock(); + +private: + OwnPtr<WebKit::WebStorageNamespace> m_storageNamespace; + StorageType m_storageType; +}; + +} // namespace WebCore + +#endif // ENABLE(DOM_STORAGE) + +#endif // StorageNamespaceProxy_h diff --git a/WebKit/chromium/src/SuggestionsPopupMenuClient.cpp b/WebKit/chromium/src/SuggestionsPopupMenuClient.cpp new file mode 100644 index 0000000..b4a77a3 --- /dev/null +++ b/WebKit/chromium/src/SuggestionsPopupMenuClient.cpp @@ -0,0 +1,186 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "SuggestionsPopupMenuClient.h" + +#include "CSSStyleSelector.h" +#include "CSSValueKeywords.h" +#include "Chrome.h" +#include "FrameView.h" +#include "HTMLInputElement.h" +#include "RenderTheme.h" +#include "WebViewImpl.h" + +using namespace WebCore; + +namespace WebKit { + +SuggestionsPopupMenuClient::SuggestionsPopupMenuClient() + : m_textField(0) + , m_selectedIndex(0) +{ +} + +SuggestionsPopupMenuClient::~SuggestionsPopupMenuClient() +{ +} + +// FIXME: Implement this per-derived class? +void SuggestionsPopupMenuClient::valueChanged(unsigned listIndex, bool fireEvents) +{ + m_textField->setValue(getSuggestion(listIndex)); + + WebViewImpl* webView = getWebView(); + if (!webView) + return; + + EditorClientImpl* editor = + static_cast<EditorClientImpl*>(webView->page()->editorClient()); + ASSERT(editor); + editor->onAutofillSuggestionAccepted( + static_cast<HTMLInputElement*>(m_textField.get())); +} + +String SuggestionsPopupMenuClient::itemText(unsigned listIndex) const +{ + return getSuggestion(listIndex); +} + +PopupMenuStyle SuggestionsPopupMenuClient::itemStyle(unsigned listIndex) const +{ + return *m_style; +} + +PopupMenuStyle SuggestionsPopupMenuClient::menuStyle() const +{ + return *m_style; +} + +int SuggestionsPopupMenuClient::clientPaddingLeft() const +{ + // Bug http://crbug.com/7708 seems to indicate the style can be 0. + RenderStyle* style = textFieldStyle(); + if (!style) + return 0; + + return RenderTheme::defaultTheme()->popupInternalPaddingLeft(style); +} + +int SuggestionsPopupMenuClient::clientPaddingRight() const +{ + // Bug http://crbug.com/7708 seems to indicate the style can be 0. + RenderStyle* style = textFieldStyle(); + if (!style) + return 0; + + return RenderTheme::defaultTheme()->popupInternalPaddingRight(style); +} + +void SuggestionsPopupMenuClient::popupDidHide() +{ + WebViewImpl* webView = getWebView(); + if (webView) + webView->suggestionsPopupDidHide(); +} + +void SuggestionsPopupMenuClient::setTextFromItem(unsigned listIndex) +{ + m_textField->setValue(getSuggestion(listIndex)); +} + +FontSelector* SuggestionsPopupMenuClient::fontSelector() const +{ + return m_textField->document()->styleSelector()->fontSelector(); +} + +HostWindow* SuggestionsPopupMenuClient::hostWindow() const +{ + return m_textField->document()->view()->hostWindow(); +} + +PassRefPtr<Scrollbar> SuggestionsPopupMenuClient::createScrollbar( + ScrollbarClient* client, + ScrollbarOrientation orientation, + ScrollbarControlSize size) +{ + return Scrollbar::createNativeScrollbar(client, orientation, size); +} + +RenderStyle* SuggestionsPopupMenuClient::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; +} + +void SuggestionsPopupMenuClient::initialize(HTMLInputElement* textField, + int defaultSuggestionIndex) +{ + m_textField = textField; + m_selectedIndex = defaultSuggestionIndex; + + FontDescription fontDescription; + RenderTheme::defaultTheme()->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())); +} + +WebViewImpl* SuggestionsPopupMenuClient::getWebView() const +{ + Frame* frame = m_textField->document()->frame(); + if (!frame) + return 0; + + Page* page = frame->page(); + if (!page) + return 0; + + return static_cast<ChromeClientImpl*>(page->chrome()->client())->webView(); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/SuggestionsPopupMenuClient.h b/WebKit/chromium/src/SuggestionsPopupMenuClient.h new file mode 100644 index 0000000..edc4c09 --- /dev/null +++ b/WebKit/chromium/src/SuggestionsPopupMenuClient.h @@ -0,0 +1,109 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "PopupMenuClient.h" + +#ifndef SuggestionsPopupMenuClient_h +#define SuggestionsPopupMenuClient_h + +namespace WebCore { +class HTMLInputElement; +class PopupMenuStyle; +class RenderStyle; +} + +namespace WebKit { +class WebString; +class WebViewImpl; +template <typename T> class WebVector; + +// The Suggestions popup menu client, used to display a list of suggestions. +class SuggestionsPopupMenuClient : public WebCore::PopupMenuClient { +public: + SuggestionsPopupMenuClient(); + virtual ~SuggestionsPopupMenuClient(); + + // Returns the number of suggestions available. + virtual unsigned getSuggestionsCount() const = 0; + + // Returns the suggestion at |listIndex|. + virtual WebString getSuggestion(unsigned listIndex) const = 0; + + // Removes the suggestion at |listIndex| from the list of suggestions. + virtual void removeSuggestionAtIndex(unsigned listIndex) = 0; + + // 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 getSuggestionsCount(); } + 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); + +protected: + void initialize(WebCore::HTMLInputElement* textField, + int defaultSuggestionIndex); + + int getSelectedIndex() const { return m_selectedIndex; } + void setSelectedIndex(int index) { m_selectedIndex = index; } + + WebViewImpl* getWebView() const; + WebCore::HTMLInputElement* getTextField() const { return m_textField.get(); } + +private: + WebCore::RenderStyle* textFieldStyle() const; + + RefPtr<WebCore::HTMLInputElement> m_textField; + int m_selectedIndex; + OwnPtr<WebCore::PopupMenuStyle> m_style; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/ToolsAgent.h b/WebKit/chromium/src/ToolsAgent.h new file mode 100644 index 0000000..ab48153 --- /dev/null +++ b/WebKit/chromium/src/ToolsAgent.h @@ -0,0 +1,66 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ToolsAgent_h +#define ToolsAgent_h + +#include "DevToolsRPC.h" + +namespace WebKit { + +// Tools agent provides API for enabling / disabling other agents as well as +// API for auxiliary UI functions such as dom elements highlighting. +#define TOOLS_AGENT_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3, METHOD4, METHOD5) \ + /* Dispatches given function on the InspectorController object */ \ + METHOD3(dispatchOnInspectorController, int /* call_id */, \ + String /* function_name */, String /* json_args */) \ + \ + /* Dispatches given function on the InjectedScript object */ \ + METHOD5(dispatchOnInjectedScript, int /* call_id */, \ + int /* injected_script_id */, String /* function_name */, \ + String /* json_args */, bool /* async */) + +DEFINE_RPC_CLASS(ToolsAgent, TOOLS_AGENT_STRUCT) + +#define TOOLS_AGENT_DELEGATE_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3, METHOD4, METHOD5) \ + /* Updates focused node on the client. */ \ + METHOD1(frameNavigate, String /* url */) \ + \ + /* Response to the DispatchOn*. */ \ + METHOD3(didDispatchOn, int /* call_id */, String /* result */, String /* exception */) \ + \ + /* Sends InspectorFrontend message to be dispatched on client. */ \ + METHOD1(dispatchOnClient, String /* data */) + +DEFINE_RPC_CLASS(ToolsAgentDelegate, TOOLS_AGENT_DELEGATE_STRUCT) + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/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..c386d44 --- /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::isMultiSelectable() const +{ + if (!m_private) + return 0; + + m_private->updateBackingStore(); + return m_private->isMultiSelectable(); +} + +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/WebAnimationControllerImpl.cpp b/WebKit/chromium/src/WebAnimationControllerImpl.cpp new file mode 100644 index 0000000..32a7a61 --- /dev/null +++ b/WebKit/chromium/src/WebAnimationControllerImpl.cpp @@ -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. + */ + +#include "config.h" +#include "WebAnimationControllerImpl.h" + +#include "AnimationController.h" +#include "Element.h" + +#include "WebElement.h" +#include "WebFrameImpl.h" +#include "WebString.h" + +using namespace WebCore; + +namespace WebKit { + +WebAnimationControllerImpl::WebAnimationControllerImpl(WebFrameImpl* frameImpl) + : m_frameImpl(frameImpl) +{ + ASSERT(m_frameImpl); +} + +AnimationController* WebAnimationControllerImpl::animationController() const +{ + if (!m_frameImpl->frame()) + return 0; + return m_frameImpl->frame()->animation(); +} + +bool WebAnimationControllerImpl::pauseAnimationAtTime(WebElement& element, + const WebString& animationName, + double time) +{ + AnimationController* controller = animationController(); + if (!controller) + return 0; + return controller->pauseAnimationAtTime(PassRefPtr<Element>(element)->renderer(), + animationName, + time); +} + +bool WebAnimationControllerImpl::pauseTransitionAtTime(WebElement& element, + const WebString& propertyName, + double time) +{ + AnimationController* controller = animationController(); + if (!controller) + return 0; + return controller->pauseTransitionAtTime(PassRefPtr<Element>(element)->renderer(), + propertyName, + time); +} + +unsigned WebAnimationControllerImpl::numberOfActiveAnimations() const +{ + AnimationController* controller = animationController(); + if (!controller) + return 0; + return controller->numberOfActiveAnimations(); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebAnimationControllerImpl.h b/WebKit/chromium/src/WebAnimationControllerImpl.h new file mode 100644 index 0000000..8b0676e --- /dev/null +++ b/WebKit/chromium/src/WebAnimationControllerImpl.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 WebAnimationControllerImpl_h +#define WebAnimationControllerImpl_h + +// FIXME: This relative path is a temporary hack to support using this +// header from webkit/glue. +#include "../public/WebAnimationController.h" + +namespace WebCore { +class AnimationController; +} + +namespace WebKit { +class WebFrameImpl; + +class WebAnimationControllerImpl : public WebAnimationController { +public: + explicit WebAnimationControllerImpl(WebFrameImpl*); + virtual ~WebAnimationControllerImpl() { } + + virtual bool pauseAnimationAtTime(WebElement&, + const WebString& animationName, + double time); + virtual bool pauseTransitionAtTime(WebElement&, + const WebString& propertyName, + double time); + virtual unsigned numberOfActiveAnimations() const; +private: + WebFrameImpl* m_frameImpl; + WebCore::AnimationController* animationController() const; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/WebBindings.cpp b/WebKit/chromium/src/WebBindings.cpp new file mode 100644 index 0000000..04f2f85 --- /dev/null +++ b/WebKit/chromium/src/WebBindings.cpp @@ -0,0 +1,326 @@ +/* + * 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 "V8BindingState.h" +#include "V8DOMWrapper.h" +#include "V8Event.h" +#include "V8Helpers.h" +#include "V8Proxy.h" +#include "V8Range.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 = V8Event::toNative(v8::Handle<v8::Object>::Cast(currentEvent)); + if (!event) + return false; + + // Check that the given npobj is that event. + V8NPObject* object = reinterpret_cast<V8NPObject*>(npobj); + Event* given = V8Event::toNative(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 || !V8BindingSecurity::canAccessFrame(V8BindingState::Only(), 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 = V8Range::toNative(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..5a315cf --- /dev/null +++ b/WebKit/chromium/src/WebDataSourceImpl.cpp @@ -0,0 +1,182 @@ +/* + * 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 "ApplicationCacheHostInternal.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); +} + +WebApplicationCacheHost* WebDataSourceImpl::applicationCacheHost() { +#if ENABLE(OFFLINE_WEB_APPLICATIONS) + return ApplicationCacheHostInternal::toWebApplicationCacheHost(DocumentLoader::applicationCacheHost()); +#else + return 0; +#endif +} + +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..f868e95 --- /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*); + virtual WebApplicationCacheHost* applicationCacheHost(); + + 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..50b9220 --- /dev/null +++ b/WebKit/chromium/src/WebDatabase.cpp @@ -0,0 +1,151 @@ +/* + * 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 "DatabaseTask.h" +#include "DatabaseThread.h" +#include "DatabaseTracker.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); +} + +void WebDatabase::closeDatabaseImmediately(const WebString& originIdentifier, const WebString& databaseName) +{ + HashSet<RefPtr<Database> > databaseHandles; + PassRefPtr<SecurityOrigin> originPrp(*WebSecurityOrigin::createFromDatabaseIdentifier(originIdentifier)); + RefPtr<SecurityOrigin> origin = originPrp; + DatabaseTracker::tracker().getOpenDatabases(origin.get(), databaseName, &databaseHandles); + for (HashSet<RefPtr<Database> >::iterator it = databaseHandles.begin(); it != databaseHandles.end(); ++it) { + Database* database = it->get(); + DatabaseThread* databaseThread = database->scriptExecutionContext()->databaseThread(); + if (databaseThread && !databaseThread->terminationRequested()) { + database->stop(); + databaseThread->scheduleTask(DatabaseCloseTask::create(database, 0)); + } + } +} + +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/WebDevToolsAgentImpl.cpp b/WebKit/chromium/src/WebDevToolsAgentImpl.cpp new file mode 100644 index 0000000..9ce35b4 --- /dev/null +++ b/WebKit/chromium/src/WebDevToolsAgentImpl.cpp @@ -0,0 +1,563 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebDevToolsAgentImpl.h" + +#include "BoundObject.h" +#include "DebuggerAgentImpl.h" +#include "DebuggerAgentManager.h" +#include "Document.h" +#include "EventListener.h" +#include "InjectedScriptHost.h" +#include "InspectorBackend.h" +#include "InspectorController.h" +#include "InspectorFrontend.h" +#include "InspectorResource.h" +#include "Node.h" +#include "Page.h" +#include "PlatformString.h" +#include "ProfilerAgentImpl.h" +#include "ResourceError.h" +#include "ResourceRequest.h" +#include "ResourceResponse.h" +#include "ScriptObject.h" +#include "ScriptState.h" +#include "ScriptValue.h" +#include "V8Binding.h" +#include "V8InspectorBackend.h" +#include "V8Proxy.h" +#include "V8Utilities.h" +#include "WebDataSource.h" +#include "WebDevToolsAgentClient.h" +#include "WebDevToolsMessageData.h" +#include "WebFrameImpl.h" +#include "WebString.h" +#include "WebURL.h" +#include "WebURLError.h" +#include "WebURLRequest.h" +#include "WebURLResponse.h" +#include "WebViewImpl.h" +#include <wtf/Noncopyable.h> +#include <wtf/OwnPtr.h> + +using WebCore::Document; +using WebCore::DocumentLoader; +using WebCore::FrameLoader; +using WebCore::InjectedScriptHost; +using WebCore::InspectorBackend; +using WebCore::InspectorController; +using WebCore::InspectorFrontend; +using WebCore::InspectorResource; +using WebCore::Node; +using WebCore::Page; +using WebCore::ResourceError; +using WebCore::ResourceRequest; +using WebCore::ResourceResponse; +using WebCore::SafeAllocation; +using WebCore::ScriptObject; +using WebCore::ScriptState; +using WebCore::ScriptValue; +using WebCore::String; +using WebCore::V8ClassIndex; +using WebCore::V8DOMWrapper; +using WebCore::V8InspectorBackend; +using WebCore::V8Proxy; + +namespace WebKit { + +namespace { + +void InspectorBackendWeakReferenceCallback(v8::Persistent<v8::Value> object, void* parameter) +{ + InspectorBackend* backend = static_cast<InspectorBackend*>(parameter); + backend->deref(); + object.Dispose(); +} + +void SetApuAgentEnabledInUtilityContext(v8::Handle<v8::Context> context, bool enabled) +{ + v8::HandleScope handleScope; + v8::Context::Scope contextScope(context); + v8::Handle<v8::Object> dispatcher = v8::Local<v8::Object>::Cast( + context->Global()->Get(v8::String::New("ApuAgentDispatcher"))); + if (dispatcher.IsEmpty()) + return; + dispatcher->Set(v8::String::New("enabled"), v8::Boolean::New(enabled)); +} + +// TODO(pfeldman): Make this public in WebDevToolsAgent API. +static const char kApuAgentFeatureName[] = "apu-agent"; + +// Keep these in sync with the ones in inject_dispatch.js. +static const char kTimelineFeatureName[] = "timeline-profiler"; +static const char kResourceTrackingFeatureName[] = "resource-tracking"; + +class IORPCDelegate : public DevToolsRPC::Delegate, public Noncopyable { +public: + IORPCDelegate() { } + virtual ~IORPCDelegate() { } + virtual void sendRpcMessage(const WebDevToolsMessageData& data) + { + WebDevToolsAgentClient::sendMessageToFrontendOnIOThread(data); + } +}; + +} // namespace + +WebDevToolsAgentImpl::WebDevToolsAgentImpl( + WebViewImpl* webViewImpl, + WebDevToolsAgentClient* client) + : m_hostId(client->hostIdentifier()) + , m_client(client) + , m_webViewImpl(webViewImpl) + , m_apuAgentEnabled(false) + , m_resourceTrackingWasEnabled(false) + , m_attached(false) +{ + m_debuggerAgentDelegateStub.set(new DebuggerAgentDelegateStub(this)); + m_toolsAgentDelegateStub.set(new ToolsAgentDelegateStub(this)); + m_apuAgentDelegateStub.set(new ApuAgentDelegateStub(this)); +} + +WebDevToolsAgentImpl::~WebDevToolsAgentImpl() +{ + DebuggerAgentManager::onWebViewClosed(m_webViewImpl); + disposeUtilityContext(); +} + +void WebDevToolsAgentImpl::disposeUtilityContext() +{ + if (!m_utilityContext.IsEmpty()) { + m_utilityContext.Dispose(); + m_utilityContext.Clear(); + } +} + +void WebDevToolsAgentImpl::unhideResourcesPanelIfNecessary() +{ + InspectorController* ic = m_webViewImpl->page()->inspectorController(); + ic->ensureResourceTrackingSettingsLoaded(); + String command = String::format("[\"setResourcesPanelEnabled\", %s]", + ic->resourceTrackingEnabled() ? "true" : "false"); + m_toolsAgentDelegateStub->dispatchOnClient(command); +} + +void WebDevToolsAgentImpl::attach() +{ + if (m_attached) + return; + m_debuggerAgentImpl.set( + new DebuggerAgentImpl(m_webViewImpl, + m_debuggerAgentDelegateStub.get(), + this)); + resetInspectorFrontendProxy(); + unhideResourcesPanelIfNecessary(); + // Allow controller to send messages to the frontend. + InspectorController* ic = inspectorController(); + + { // TODO(yurys): the source should have already been pushed by the frontend. + v8::HandleScope scope; + v8::Context::Scope contextScope(m_utilityContext); + v8::Handle<v8::Value> constructorValue = m_utilityContext->Global()->Get( + v8::String::New("injectedScriptConstructor")); + if (constructorValue->IsFunction()) { + String source = WebCore::toWebCoreString(constructorValue); + ic->injectedScriptHost()->setInjectedScriptSource("(" + source + ")"); + } + } + + ic->setWindowVisible(true, false); + m_attached = true; +} + +void WebDevToolsAgentImpl::detach() +{ + // Prevent controller from sending messages to the frontend. + InspectorController* ic = m_webViewImpl->page()->inspectorController(); + ic->hideHighlight(); + ic->close(); + disposeUtilityContext(); + m_debuggerAgentImpl.set(0); + m_attached = false; + m_apuAgentEnabled = false; +} + +void WebDevToolsAgentImpl::didNavigate() +{ + DebuggerAgentManager::onNavigate(); +} + +void WebDevToolsAgentImpl::didCommitProvisionalLoad(WebFrameImpl* webframe, bool isNewNavigation) +{ + if (!m_attached) + return; + WebDataSource* ds = webframe->dataSource(); + const WebURLRequest& request = ds->request(); + WebURL url = ds->hasUnreachableURL() ? + ds->unreachableURL() : + request.url(); + if (!webframe->parent()) { + resetInspectorFrontendProxy(); + m_toolsAgentDelegateStub->frameNavigate(WebCore::KURL(url).string()); + SetApuAgentEnabledInUtilityContext(m_utilityContext, m_apuAgentEnabled); + unhideResourcesPanelIfNecessary(); + } +} + +void WebDevToolsAgentImpl::didClearWindowObject(WebFrameImpl* webframe) +{ + DebuggerAgentManager::setHostId(webframe, m_hostId); + if (m_attached) { + // Push context id into the client if it is already attached. + m_debuggerAgentDelegateStub->setContextId(m_hostId); + } +} + +void WebDevToolsAgentImpl::forceRepaint() +{ + m_client->forceRepaint(); +} + +void WebDevToolsAgentImpl::dispatchOnInspectorController(int callId, const String& functionName, const String& jsonArgs) +{ + String result; + String exception; + result = m_debuggerAgentImpl->executeUtilityFunction(m_utilityContext, callId, + "InspectorControllerDispatcher", functionName, jsonArgs, false /* is sync */, &exception); + m_toolsAgentDelegateStub->didDispatchOn(callId, result, exception); +} + +void WebDevToolsAgentImpl::dispatchOnInjectedScript(int callId, int injectedScriptId, const String& functionName, const String& jsonArgs, bool async) +{ + inspectorController()->inspectorBackend()->dispatchOnInjectedScript( + callId, + injectedScriptId, + functionName, + jsonArgs, + async); +} + +void WebDevToolsAgentImpl::dispatchMessageFromFrontend(const WebDevToolsMessageData& data) +{ + if (ToolsAgentDispatch::dispatch(this, data)) + return; + + if (!m_attached) + return; + + if (m_debuggerAgentImpl.get() && DebuggerAgentDispatch::dispatch(m_debuggerAgentImpl.get(), data)) + return; +} + +void WebDevToolsAgentImpl::inspectElementAt(const WebPoint& point) +{ + m_webViewImpl->inspectElementAt(point); +} + +void WebDevToolsAgentImpl::setRuntimeFeatureEnabled(const WebString& feature, bool enabled) +{ + if (feature == kApuAgentFeatureName) + setApuAgentEnabled(enabled); + else if (feature == kTimelineFeatureName) + setTimelineProfilingEnabled(enabled); + else if (feature == kResourceTrackingFeatureName) { + InspectorController* ic = m_webViewImpl->page()->inspectorController(); + if (enabled) + ic->enableResourceTracking(false /* not sticky */, false /* no reload */); + else + ic->disableResourceTracking(false /* not sticky */); + } +} + +void WebDevToolsAgentImpl::sendRpcMessage(const WebDevToolsMessageData& data) +{ + m_client->sendMessageToFrontend(data); +} + +void WebDevToolsAgentImpl::compileUtilityScripts() +{ + v8::HandleScope handleScope; + v8::Context::Scope contextScope(m_utilityContext); + // Inject javascript into the context. + WebCString injectedScriptJs = m_client->injectedScriptSource(); + v8::Script::Compile(v8::String::New( + injectedScriptJs.data(), + injectedScriptJs.length()))->Run(); + WebCString injectDispatchJs = m_client->injectedScriptDispatcherSource(); + v8::Script::Compile(v8::String::New( + injectDispatchJs.data(), + injectDispatchJs.length()))->Run(); +} + +void WebDevToolsAgentImpl::initDevToolsAgentHost() +{ + BoundObject devtoolsAgentHost(m_utilityContext, this, "DevToolsAgentHost"); + devtoolsAgentHost.addProtoFunction( + "dispatch", + WebDevToolsAgentImpl::jsDispatchOnClient); + devtoolsAgentHost.addProtoFunction( + "dispatchToApu", + WebDevToolsAgentImpl::jsDispatchToApu); + devtoolsAgentHost.addProtoFunction( + "evaluateOnSelf", + WebDevToolsAgentImpl::jsEvaluateOnSelf); + devtoolsAgentHost.addProtoFunction( + "runtimeFeatureStateChanged", + WebDevToolsAgentImpl::jsOnRuntimeFeatureStateChanged); + devtoolsAgentHost.build(); + + v8::HandleScope scope; + v8::Context::Scope utilityScope(m_utilityContext); + // Call custom code to create inspector backend wrapper in the utility context + // instead of calling V8DOMWrapper::convertToV8Object that would create the + // wrapper in the Page main frame context. + v8::Handle<v8::Object> backendWrapper = createInspectorBackendV8Wrapper(); + if (backendWrapper.IsEmpty()) + return; + m_utilityContext->Global()->Set(v8::String::New("InspectorBackend"), backendWrapper); +} + +v8::Local<v8::Object> WebDevToolsAgentImpl::createInspectorBackendV8Wrapper() +{ + V8ClassIndex::V8WrapperType descriptorType = V8ClassIndex::INSPECTORBACKEND; + v8::Handle<v8::Function> function = V8InspectorBackend::GetTemplate()->GetFunction(); + if (function.IsEmpty()) { + // Return if allocation failed. + return v8::Local<v8::Object>(); + } + v8::Local<v8::Object> instance = SafeAllocation::newInstance(function); + if (instance.IsEmpty()) { + // Avoid setting the wrapper if allocation failed. + return v8::Local<v8::Object>(); + } + InspectorBackend* backend = m_webViewImpl->page()->inspectorController()->inspectorBackend(); + V8DOMWrapper::setDOMWrapper(instance, V8ClassIndex::ToInt(descriptorType), backend); + // Create a weak reference to the v8 wrapper of InspectorBackend to deref + // InspectorBackend when the wrapper is garbage collected. + backend->ref(); + v8::Persistent<v8::Object> weakHandle = v8::Persistent<v8::Object>::New(instance); + weakHandle.MakeWeak(backend, &InspectorBackendWeakReferenceCallback); + return instance; +} + +void WebDevToolsAgentImpl::resetInspectorFrontendProxy() +{ + disposeUtilityContext(); + m_debuggerAgentImpl->createUtilityContext(m_webViewImpl->page()->mainFrame(), &m_utilityContext); + compileUtilityScripts(); + initDevToolsAgentHost(); + + v8::HandleScope scope; + v8::Context::Scope contextScope(m_utilityContext); + ScriptState* state = ScriptState::forContext( + v8::Local<v8::Context>::New(m_utilityContext)); + InspectorController* ic = inspectorController(); + ic->setFrontendProxyObject(state, ScriptObject(state, m_utilityContext->Global())); +} + +void WebDevToolsAgentImpl::setApuAgentEnabled(bool enabled) +{ + m_apuAgentEnabled = enabled; + SetApuAgentEnabledInUtilityContext(m_utilityContext, enabled); + InspectorController* ic = m_webViewImpl->page()->inspectorController(); + if (enabled) { + m_resourceTrackingWasEnabled = ic->resourceTrackingEnabled(); + ic->startTimelineProfiler(); + if (!m_resourceTrackingWasEnabled) { + // TODO(knorton): Introduce some kind of agents dependency here so that + // user could turn off resource tracking while apu agent is on. + ic->enableResourceTracking(false, false); + } + m_debuggerAgentImpl->setAutoContinueOnException(true); + } else { + ic->stopTimelineProfiler(); + if (!m_resourceTrackingWasEnabled) + ic->disableResourceTracking(false); + m_resourceTrackingWasEnabled = false; + } + m_client->runtimeFeatureStateChanged( + kApuAgentFeatureName, + enabled); +} + +// static +v8::Handle<v8::Value> WebDevToolsAgentImpl::jsDispatchOnClient(const v8::Arguments& args) +{ + v8::TryCatch exceptionCatcher; + String message = WebCore::toWebCoreStringWithNullCheck(args[0]); + if (message.isEmpty() || exceptionCatcher.HasCaught()) + return v8::Undefined(); + WebDevToolsAgentImpl* agent = static_cast<WebDevToolsAgentImpl*>(v8::External::Cast(*args.Data())->Value()); + agent->m_toolsAgentDelegateStub->dispatchOnClient(message); + return v8::Undefined(); +} + +// static +v8::Handle<v8::Value> WebDevToolsAgentImpl::jsDispatchToApu(const v8::Arguments& args) +{ + v8::TryCatch exceptionCatcher; + String message = WebCore::toWebCoreStringWithNullCheck(args[0]); + if (message.isEmpty() || exceptionCatcher.HasCaught()) + return v8::Undefined(); + WebDevToolsAgentImpl* agent = static_cast<WebDevToolsAgentImpl*>( + v8::External::Cast(*args.Data())->Value()); + agent->m_apuAgentDelegateStub->dispatchToApu(message); + return v8::Undefined(); +} + +// static +v8::Handle<v8::Value> WebDevToolsAgentImpl::jsEvaluateOnSelf(const v8::Arguments& args) +{ + String code; + { + v8::TryCatch exceptionCatcher; + code = WebCore::toWebCoreStringWithNullCheck(args[0]); + if (code.isEmpty() || exceptionCatcher.HasCaught()) + return v8::Undefined(); + } + WebDevToolsAgentImpl* agent = static_cast<WebDevToolsAgentImpl*>(v8::External::Cast(*args.Data())->Value()); + v8::Context::Scope(agent->m_utilityContext); + V8Proxy* proxy = V8Proxy::retrieve(agent->m_webViewImpl->page()->mainFrame()); + v8::Local<v8::Value> result = proxy->runScript(v8::Script::Compile(v8::String::New(code.utf8().data())), true); + return result; +} + +// static +v8::Handle<v8::Value> WebDevToolsAgentImpl::jsOnRuntimeFeatureStateChanged(const v8::Arguments& args) +{ + v8::TryCatch exceptionCatcher; + String feature = WebCore::toWebCoreStringWithNullCheck(args[0]); + bool enabled = args[1]->ToBoolean()->Value(); + if (feature.isEmpty() || exceptionCatcher.HasCaught()) + return v8::Undefined(); + WebDevToolsAgentImpl* agent = static_cast<WebDevToolsAgentImpl*>(v8::External::Cast(*args.Data())->Value()); + agent->m_client->runtimeFeatureStateChanged(feature, enabled); + return v8::Undefined(); +} + + +WebCore::InspectorController* WebDevToolsAgentImpl::inspectorController() +{ + if (Page* page = m_webViewImpl->page()) + return page->inspectorController(); + return 0; +} + + +//------- plugin resource load notifications --------------- +void WebDevToolsAgentImpl::identifierForInitialRequest( + unsigned long resourceId, + WebFrame* frame, + const WebURLRequest& request) +{ + if (InspectorController* ic = inspectorController()) { + WebFrameImpl* webFrameImpl = static_cast<WebFrameImpl*>(frame); + FrameLoader* frameLoader = webFrameImpl->frame()->loader(); + DocumentLoader* loader = frameLoader->activeDocumentLoader(); + ic->identifierForInitialRequest(resourceId, loader, request.toResourceRequest()); + } +} + +void WebDevToolsAgentImpl::willSendRequest(unsigned long resourceId, const WebURLRequest& request) +{ + if (InspectorController* ic = inspectorController()) + ic->willSendRequest(resourceId, request.toResourceRequest(), ResourceResponse()); +} + +void WebDevToolsAgentImpl::didReceiveData(unsigned long resourceId, int length) +{ + if (InspectorController* ic = inspectorController()) + ic->didReceiveContentLength(resourceId, length); +} + +void WebDevToolsAgentImpl::didReceiveResponse(unsigned long resourceId, const WebURLResponse& response) +{ + if (InspectorController* ic = inspectorController()) + ic->didReceiveResponse(resourceId, response.toResourceResponse()); +} + +void WebDevToolsAgentImpl::didFinishLoading(unsigned long resourceId) +{ + if (InspectorController* ic = inspectorController()) + ic->didFinishLoading(resourceId); +} + +void WebDevToolsAgentImpl::didFailLoading(unsigned long resourceId, const WebURLError& error) +{ + ResourceError resourceError; + if (InspectorController* ic = inspectorController()) + ic->didFailLoading(resourceId, resourceError); +} + +void WebDevToolsAgentImpl::evaluateInWebInspector(long callId, const WebString& script) +{ + InspectorController* ic = inspectorController(); + ic->evaluateForTestInFrontend(callId, script); +} + +void WebDevToolsAgentImpl::setTimelineProfilingEnabled(bool enabled) +{ + InspectorController* ic = inspectorController(); + if (enabled) + ic->startTimelineProfiler(); + else + ic->stopTimelineProfiler(); +} + +WebDevToolsAgent* WebDevToolsAgent::create(WebView* webview, WebDevToolsAgentClient* client) +{ + return new WebDevToolsAgentImpl(static_cast<WebViewImpl*>(webview), client); +} + +void WebDevToolsAgent::executeDebuggerCommand(const WebString& command, int callerId) +{ + DebuggerAgentManager::executeDebuggerCommand(command, callerId); +} + +void WebDevToolsAgent::debuggerPauseScript() +{ + DebuggerAgentManager::pauseScript(); +} + +void WebDevToolsAgent::setMessageLoopDispatchHandler(MessageLoopDispatchHandler handler) +{ + DebuggerAgentManager::setMessageLoopDispatchHandler(handler); +} + +bool WebDevToolsAgent::dispatchMessageFromFrontendOnIOThread(const WebDevToolsMessageData& data) +{ + IORPCDelegate transport; + ProfilerAgentDelegateStub stub(&transport); + ProfilerAgentImpl agent(&stub); + return ProfilerAgentDispatch::dispatch(&agent, data); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebDevToolsAgentImpl.h b/WebKit/chromium/src/WebDevToolsAgentImpl.h new file mode 100644 index 0000000..1f81c6d --- /dev/null +++ b/WebKit/chromium/src/WebDevToolsAgentImpl.h @@ -0,0 +1,141 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebDevToolsAgentImpl_h +#define WebDevToolsAgentImpl_h + +#include "APUAgentDelegate.h" +#include "DevToolsRPC.h" +#include "ToolsAgent.h" +#include "WebDevToolsAgentPrivate.h" + +#include <v8.h> +#include <wtf/OwnPtr.h> + +namespace WebCore { +class Document; +class InspectorController; +class Node; +class String; +} + +namespace WebKit { + +class DebuggerAgentDelegateStub; +class DebuggerAgentImpl; +class WebDevToolsAgentClient; +class WebFrame; +class WebFrameImpl; +class WebString; +class WebURLRequest; +class WebURLResponse; +class WebViewImpl; +struct WebURLError; +struct WebDevToolsMessageData; + +class WebDevToolsAgentImpl : public WebDevToolsAgentPrivate, + public ToolsAgent, + public DevToolsRPC::Delegate { +public: + WebDevToolsAgentImpl(WebViewImpl* webViewImpl, WebDevToolsAgentClient* client); + virtual ~WebDevToolsAgentImpl(); + + // ToolsAgent implementation. + virtual void dispatchOnInspectorController(int callId, const WebCore::String& functionName, const WebCore::String& jsonArgs); + virtual void dispatchOnInjectedScript(int callId, int injectedScriptId, const WebCore::String& functionName, const WebCore::String& jsonArgs, bool async); + + // WebDevToolsAgentPrivate implementation. + virtual void didClearWindowObject(WebFrameImpl* frame); + virtual void didCommitProvisionalLoad(WebFrameImpl* frame, bool isNewNavigation); + + // WebDevToolsAgent implementation. + virtual void attach(); + virtual void detach(); + virtual void didNavigate(); + virtual void dispatchMessageFromFrontend(const WebDevToolsMessageData& data); + virtual void inspectElementAt(const WebPoint& point); + virtual void evaluateInWebInspector(long callId, const WebString& script); + virtual void setRuntimeFeatureEnabled(const WebString& feature, bool enabled); + virtual void setTimelineProfilingEnabled(bool enable); + + virtual void identifierForInitialRequest(unsigned long, WebFrame*, const WebURLRequest&); + virtual void willSendRequest(unsigned long, const WebURLRequest&); + virtual void didReceiveData(unsigned long, int length); + virtual void didReceiveResponse(unsigned long, const WebURLResponse&); + virtual void didFinishLoading(unsigned long); + virtual void didFailLoading(unsigned long, const WebURLError&); + + // DevToolsRPC::Delegate implementation. + virtual void sendRpcMessage(const WebDevToolsMessageData& data); + + void forceRepaint(); + + int hostId() { return m_hostId; } + +private: + static v8::Handle<v8::Value> jsDispatchOnClient(const v8::Arguments& args); + static v8::Handle<v8::Value> jsDispatchToApu(const v8::Arguments& args); + static v8::Handle<v8::Value> jsEvaluateOnSelf(const v8::Arguments& args); + static v8::Handle<v8::Value> jsOnRuntimeFeatureStateChanged(const v8::Arguments& args); + + void disposeUtilityContext(); + void unhideResourcesPanelIfNecessary(); + + void compileUtilityScripts(); + void initDevToolsAgentHost(); + void resetInspectorFrontendProxy(); + void setApuAgentEnabled(bool enabled); + + WebCore::InspectorController* inspectorController(); + + // Creates InspectorBackend v8 wrapper in the utility context so that it's + // methods prototype is Function.protoype object from the utility context. + // Otherwise some useful methods defined on Function.prototype(such as bind) + // are missing for InspectorController native methods. + v8::Local<v8::Object> createInspectorBackendV8Wrapper(); + + int m_hostId; + WebDevToolsAgentClient* m_client; + WebViewImpl* m_webViewImpl; + OwnPtr<DebuggerAgentDelegateStub> m_debuggerAgentDelegateStub; + OwnPtr<ToolsAgentDelegateStub> m_toolsAgentDelegateStub; + OwnPtr<DebuggerAgentImpl> m_debuggerAgentImpl; + OwnPtr<ApuAgentDelegateStub> m_apuAgentDelegateStub; + bool m_apuAgentEnabled; + bool m_resourceTrackingWasEnabled; + bool m_attached; + // TODO(pfeldman): This should not be needed once GC styles issue is fixed + // for matching rules. + v8::Persistent<v8::Context> m_utilityContext; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/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/WebDevToolsFrontendImpl.cpp b/WebKit/chromium/src/WebDevToolsFrontendImpl.cpp new file mode 100644 index 0000000..89fa6e7 --- /dev/null +++ b/WebKit/chromium/src/WebDevToolsFrontendImpl.cpp @@ -0,0 +1,395 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebDevToolsFrontendImpl.h" + +#include "BoundObject.h" +#include "ContextMenuController.h" +#include "ContextMenuItem.h" +#include "DOMWindow.h" +#include "DebuggerAgent.h" +#include "DevToolsRPCJS.h" +#include "Document.h" +#include "Event.h" +#include "Frame.h" +#include "InspectorBackend.h" +#include "InspectorController.h" +#include "InspectorFrontendHost.h" +#include "Node.h" +#include "Page.h" +#include "Pasteboard.h" +#include "PlatformString.h" +#include "ProfilerAgent.h" +#include "SecurityOrigin.h" +#include "Settings.h" +#include "ToolsAgent.h" +#include "V8Binding.h" +#include "V8DOMWrapper.h" +#include "V8InspectorFrontendHost.h" +#include "V8Node.h" +#include "V8Proxy.h" +#include "V8Utilities.h" +#include "WebDevToolsFrontendClient.h" +#include "WebFrameImpl.h" +#include "WebScriptSource.h" +#include "WebViewImpl.h" +#include <wtf/OwnPtr.h> +#include <wtf/Vector.h> + +using namespace WebCore; + +namespace WebKit { + +static v8::Local<v8::String> ToV8String(const String& s) +{ + if (s.isNull()) + return v8::Local<v8::String>(); + + return v8::String::New(reinterpret_cast<const uint16_t*>(s.characters()), s.length()); +} + +DEFINE_RPC_JS_BOUND_OBJ(DebuggerAgent, DEBUGGER_AGENT_STRUCT, DebuggerAgentDelegate, DEBUGGER_AGENT_DELEGATE_STRUCT) +DEFINE_RPC_JS_BOUND_OBJ(ProfilerAgent, PROFILER_AGENT_STRUCT, ProfilerAgentDelegate, PROFILER_AGENT_DELEGATE_STRUCT) +DEFINE_RPC_JS_BOUND_OBJ(ToolsAgent, TOOLS_AGENT_STRUCT, ToolsAgentDelegate, TOOLS_AGENT_DELEGATE_STRUCT) + +WebDevToolsFrontend* WebDevToolsFrontend::create( + WebView* view, + WebDevToolsFrontendClient* client, + const WebString& applicationLocale) +{ + return new WebDevToolsFrontendImpl( + static_cast<WebViewImpl*>(view), + client, + applicationLocale); +} + +WebDevToolsFrontendImpl::WebDevToolsFrontendImpl( + WebViewImpl* webViewImpl, + WebDevToolsFrontendClient* client, + const String& applicationLocale) + : m_webViewImpl(webViewImpl) + , m_client(client) + , m_applicationLocale(applicationLocale) + , m_loaded(false) +{ + WebFrameImpl* frame = m_webViewImpl->mainFrameImpl(); + v8::HandleScope scope; + v8::Handle<v8::Context> frameContext = V8Proxy::context(frame->frame()); + + m_debuggerAgentObj.set(new JSDebuggerAgentBoundObj(this, frameContext, "RemoteDebuggerAgent")); + m_profilerAgentObj.set(new JSProfilerAgentBoundObj(this, frameContext, "RemoteProfilerAgent")); + m_toolsAgentObj.set(new JSToolsAgentBoundObj(this, frameContext, "RemoteToolsAgent")); + + // Debugger commands should be sent using special method. + BoundObject debuggerCommandExecutorObj(frameContext, this, "RemoteDebuggerCommandExecutor"); + debuggerCommandExecutorObj.addProtoFunction( + "DebuggerCommand", + WebDevToolsFrontendImpl::jsDebuggerCommand); + debuggerCommandExecutorObj.addProtoFunction( + "DebuggerPauseScript", + WebDevToolsFrontendImpl::jsDebuggerPauseScript); + debuggerCommandExecutorObj.build(); + + BoundObject devToolsHost(frameContext, this, "InspectorFrontendHost"); + devToolsHost.addProtoFunction( + "loaded", + WebDevToolsFrontendImpl::jsLoaded); + devToolsHost.addProtoFunction( + "platform", + WebDevToolsFrontendImpl::jsPlatform); + devToolsHost.addProtoFunction( + "port", + WebDevToolsFrontendImpl::jsPort); + devToolsHost.addProtoFunction( + "copyText", + WebDevToolsFrontendImpl::jsCopyText); + devToolsHost.addProtoFunction( + "activateWindow", + WebDevToolsFrontendImpl::jsActivateWindow); + devToolsHost.addProtoFunction( + "closeWindow", + WebDevToolsFrontendImpl::jsCloseWindow); + devToolsHost.addProtoFunction( + "attach", + WebDevToolsFrontendImpl::jsDockWindow); + devToolsHost.addProtoFunction( + "detach", + WebDevToolsFrontendImpl::jsUndockWindow); + devToolsHost.addProtoFunction( + "localizedStringsURL", + WebDevToolsFrontendImpl::jsLocalizedStringsURL); + devToolsHost.addProtoFunction( + "hiddenPanels", + WebDevToolsFrontendImpl::jsHiddenPanels); + devToolsHost.addProtoFunction( + "setting", + WebDevToolsFrontendImpl::jsSetting); + devToolsHost.addProtoFunction( + "setSetting", + WebDevToolsFrontendImpl::jsSetSetting); + devToolsHost.addProtoFunction( + "windowUnloading", + WebDevToolsFrontendImpl::jsWindowUnloading); + devToolsHost.addProtoFunction( + "showContextMenu", + WebDevToolsFrontendImpl::jsShowContextMenu); + devToolsHost.build(); +} + +WebDevToolsFrontendImpl::~WebDevToolsFrontendImpl() +{ + if (m_menuProvider) + m_menuProvider->disconnect(); +} + +void WebDevToolsFrontendImpl::dispatchMessageFromAgent(const WebDevToolsMessageData& data) +{ + Vector<String> v; + v.append(data.className); + v.append(data.methodName); + for (size_t i = 0; i < data.arguments.size(); i++) + v.append(data.arguments[i]); + if (!m_loaded) { + m_pendingIncomingMessages.append(v); + return; + } + executeScript(v); +} + +void WebDevToolsFrontendImpl::executeScript(const Vector<String>& v) +{ + WebFrameImpl* frame = m_webViewImpl->mainFrameImpl(); + v8::HandleScope scope; + v8::Handle<v8::Context> frameContext = V8Proxy::context(frame->frame()); + v8::Context::Scope contextScope(frameContext); + v8::Handle<v8::Value> dispatchFunction = frameContext->Global()->Get(v8::String::New("devtools$$dispatch")); + ASSERT(dispatchFunction->IsFunction()); + v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(dispatchFunction); + Vector< v8::Handle<v8::Value> > args; + for (size_t i = 0; i < v.size(); i++) + args.append(ToV8String(v.at(i))); + function->Call(frameContext->Global(), args.size(), args.data()); +} + +void WebDevToolsFrontendImpl::dispatchOnWebInspector(const String& methodName, const String& param) +{ + WebFrameImpl* frame = m_webViewImpl->mainFrameImpl(); + v8::HandleScope scope; + v8::Handle<v8::Context> frameContext = V8Proxy::context(frame->frame()); + v8::Context::Scope contextScope(frameContext); + + v8::Handle<v8::Value> webInspector = frameContext->Global()->Get(v8::String::New("WebInspector")); + ASSERT(webInspector->IsObject()); + v8::Handle<v8::Object> webInspectorObj = v8::Handle<v8::Object>::Cast(webInspector); + + v8::Handle<v8::Value> method = webInspectorObj->Get(ToV8String(methodName)); + ASSERT(method->IsFunction()); + v8::Handle<v8::Function> methodFunc = v8::Handle<v8::Function>::Cast(method); + v8::Handle<v8::Value> args[] = { + ToV8String(param) + }; + methodFunc->Call(frameContext->Global(), 1, args); +} + +void WebDevToolsFrontendImpl::sendRpcMessage(const WebDevToolsMessageData& data) +{ + m_client->sendMessageToAgent(data); +} + +void WebDevToolsFrontendImpl::contextMenuItemSelected(ContextMenuItem* item) +{ + int itemNumber = item->action() - ContextMenuItemBaseCustomTag; + dispatchOnWebInspector("contextMenuItemSelected", String::number(itemNumber)); +} + +void WebDevToolsFrontendImpl::contextMenuCleared() +{ + dispatchOnWebInspector("contextMenuCleared", ""); +} + +v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsLoaded(const v8::Arguments& args) +{ + WebDevToolsFrontendImpl* frontend = static_cast<WebDevToolsFrontendImpl*>(v8::External::Cast(*args.Data())->Value()); + frontend->m_loaded = true; + + // Grant the devtools page the ability to have source view iframes. + Page* page = V8Proxy::retrieveFrameForEnteredContext()->page(); + SecurityOrigin* origin = page->mainFrame()->domWindow()->securityOrigin(); + origin->grantUniversalAccess(); + + for (Vector<Vector<String> >::iterator it = frontend->m_pendingIncomingMessages.begin(); + it != frontend->m_pendingIncomingMessages.end(); + ++it) { + frontend->executeScript(*it); + } + frontend->m_pendingIncomingMessages.clear(); + return v8::Undefined(); +} + +// static +v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsPlatform(const v8::Arguments& args) +{ +#if defined(OS_MACOSX) + return v8String("mac"); +#elif defined(OS_LINUX) + return v8String("linux"); +#elif defined(OS_WIN) + return v8String("windows"); +#else + return v8String("unknown"); +#endif +} + +v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsPort(const v8::Arguments& args) +{ + return v8::Undefined(); +} + +v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsCopyText(const v8::Arguments& args) +{ + String text = WebCore::toWebCoreStringWithNullCheck(args[0]); + Pasteboard::generalPasteboard()->writePlainText(text); + return v8::Undefined(); +} + +v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsActivateWindow(const v8::Arguments& args) +{ + WebDevToolsFrontendImpl* frontend = static_cast<WebDevToolsFrontendImpl*>(v8::External::Cast(*args.Data())->Value()); + frontend->m_client->activateWindow(); + return v8::Undefined(); +} + +v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsCloseWindow(const v8::Arguments& args) +{ + WebDevToolsFrontendImpl* frontend = static_cast<WebDevToolsFrontendImpl*>(v8::External::Cast(*args.Data())->Value()); + frontend->m_client->closeWindow(); + return v8::Undefined(); +} + +v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsDockWindow(const v8::Arguments& args) +{ + WebDevToolsFrontendImpl* frontend = static_cast<WebDevToolsFrontendImpl*>(v8::External::Cast(*args.Data())->Value()); + frontend->m_client->dockWindow(); + return v8::Undefined(); +} + +v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsUndockWindow(const v8::Arguments& args) +{ + WebDevToolsFrontendImpl* frontend = static_cast<WebDevToolsFrontendImpl*>(v8::External::Cast(*args.Data())->Value()); + frontend->m_client->undockWindow(); + return v8::Undefined(); +} + +v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsLocalizedStringsURL(const v8::Arguments& args) +{ + return v8::Undefined(); +} + +v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsHiddenPanels(const v8::Arguments& args) +{ + return v8String(""); +} + +v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsDebuggerCommand(const v8::Arguments& args) +{ + WebDevToolsFrontendImpl* frontend = static_cast<WebDevToolsFrontendImpl*>(v8::External::Cast(*args.Data())->Value()); + WebString command = WebCore::toWebCoreStringWithNullCheck(args[0]); + frontend->m_client->sendDebuggerCommandToAgent(command); + return v8::Undefined(); +} + +v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsSetting(const v8::Arguments& args) +{ + return v8::Undefined(); +} + +v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsSetSetting(const v8::Arguments& args) +{ + return v8::Undefined(); +} + +v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsDebuggerPauseScript(const v8::Arguments& args) +{ + WebDevToolsFrontendImpl* frontend = static_cast<WebDevToolsFrontendImpl*>(v8::External::Cast(*args.Data())->Value()); + frontend->m_client->sendDebuggerPauseScript(); + return v8::Undefined(); +} + +v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsWindowUnloading(const v8::Arguments& args) +{ + // TODO(pfeldman): Implement this. + return v8::Undefined(); +} + +v8::Handle<v8::Value> WebDevToolsFrontendImpl::jsShowContextMenu(const v8::Arguments& args) +{ + if (args.Length() < 2) + return v8::Undefined(); + + v8::Local<v8::Object> eventWrapper = v8::Local<v8::Object>::Cast(args[0]); + if (V8DOMWrapper::domWrapperType(eventWrapper) != V8ClassIndex::MOUSEEVENT) + return v8::Undefined(); + + Event* event = V8Event::toNative(eventWrapper); + if (!args[1]->IsArray()) + return v8::Undefined(); + + v8::Local<v8::Array> array = v8::Local<v8::Array>::Cast(args[1]); + Vector<ContextMenuItem*> items; + + for (size_t i = 0; i < array->Length(); ++i) { + v8::Local<v8::Object> item = v8::Local<v8::Object>::Cast(array->Get(v8::Integer::New(i))); + v8::Local<v8::Value> label = item->Get(v8::String::New("label")); + v8::Local<v8::Value> id = item->Get(v8::String::New("id")); + if (label->IsUndefined() || id->IsUndefined()) { + items.append(new ContextMenuItem(SeparatorType, + ContextMenuItemTagNoAction, + String())); + } else { + ContextMenuAction typedId = static_cast<ContextMenuAction>( + ContextMenuItemBaseCustomTag + id->ToInt32()->Value()); + items.append(new ContextMenuItem(ActionType, + typedId, + toWebCoreStringWithNullCheck(label))); + } + } + + WebDevToolsFrontendImpl* frontend = static_cast<WebDevToolsFrontendImpl*>(v8::External::Cast(*args.Data())->Value()); + + frontend->m_menuProvider = MenuProvider::create(frontend, items); + + ContextMenuController* menuController = frontend->m_webViewImpl->page()->contextMenuController(); + menuController->showContextMenu(event, frontend->m_menuProvider); + + return v8::Undefined(); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebDevToolsFrontendImpl.h b/WebKit/chromium/src/WebDevToolsFrontendImpl.h new file mode 100644 index 0000000..62b34da --- /dev/null +++ b/WebKit/chromium/src/WebDevToolsFrontendImpl.h @@ -0,0 +1,161 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef WebDevToolsFrontendImpl_h +#define WebDevToolsFrontendImpl_h + +#include "ContextMenu.h" +#include "ContextMenuProvider.h" +#include "DevToolsRPC.h" +#include "WebDevToolsFrontend.h" +#include <v8.h> +#include <wtf/HashMap.h> +#include <wtf/Noncopyable.h> +#include <wtf/OwnPtr.h> +#include <wtf/RefPtr.h> +#include <wtf/Vector.h> + +namespace WebCore { +class ContextMenuItem; +class Node; +class Page; +class String; +} + +namespace WebKit { + +class JSDebuggerAgentBoundObj; +class JSProfilerAgentBoundObj; +class JSToolsAgentBoundObj; +class WebDevToolsClientDelegate; +class WebViewImpl; +struct WebDevToolsMessageData; + +class WebDevToolsFrontendImpl : public WebKit::WebDevToolsFrontend + , public DevToolsRPC::Delegate + , public Noncopyable { +public: + WebDevToolsFrontendImpl( + WebKit::WebViewImpl* webViewImpl, + WebKit::WebDevToolsFrontendClient* client, + const String& applicationLocale); + virtual ~WebDevToolsFrontendImpl(); + + // DevToolsRPC::Delegate implementation. + virtual void sendRpcMessage(const WebKit::WebDevToolsMessageData& data); + + // WebDevToolsFrontend implementation. + virtual void dispatchMessageFromAgent(const WebKit::WebDevToolsMessageData& data); + +private: + class MenuProvider : public WebCore::ContextMenuProvider { + public: + static PassRefPtr<MenuProvider> create(WebDevToolsFrontendImpl* frontendHost, const Vector<WebCore::ContextMenuItem*>& items) + { + return adoptRef(new MenuProvider(frontendHost, items)); + } + + virtual ~MenuProvider() + { + contextMenuCleared(); + } + + void disconnect() + { + m_frontendHost = 0; + } + + virtual void populateContextMenu(WebCore::ContextMenu* menu) + { + for (size_t i = 0; i < m_items.size(); ++i) + menu->appendItem(*m_items[i]); + } + + virtual void contextMenuItemSelected(WebCore::ContextMenuItem* item) + { + if (m_frontendHost) + m_frontendHost->contextMenuItemSelected(item); + } + + virtual void contextMenuCleared() + { + if (m_frontendHost) + m_frontendHost->contextMenuCleared(); + deleteAllValues(m_items); + m_items.clear(); + } + + private: + MenuProvider(WebDevToolsFrontendImpl* frontendHost, const Vector<WebCore::ContextMenuItem*>& items) + : m_frontendHost(frontendHost) + , m_items(items) { } + WebDevToolsFrontendImpl* m_frontendHost; + Vector<WebCore::ContextMenuItem*> m_items; + }; + + void executeScript(const Vector<String>& v); + void dispatchOnWebInspector(const String& method, const String& param); + + // friend class MenuSelectionHandler; + void contextMenuItemSelected(WebCore::ContextMenuItem* menuItem); + void contextMenuCleared(); + + static v8::Handle<v8::Value> jsLoaded(const v8::Arguments& args); + static v8::Handle<v8::Value> jsPlatform(const v8::Arguments& args); + static v8::Handle<v8::Value> jsPort(const v8::Arguments& args); + static v8::Handle<v8::Value> jsCopyText(const v8::Arguments& args); + + static v8::Handle<v8::Value> jsActivateWindow(const v8::Arguments& args); + static v8::Handle<v8::Value> jsCloseWindow(const v8::Arguments& args); + static v8::Handle<v8::Value> jsDockWindow(const v8::Arguments& args); + static v8::Handle<v8::Value> jsUndockWindow(const v8::Arguments& args); + static v8::Handle<v8::Value> jsLocalizedStringsURL(const v8::Arguments& args); + static v8::Handle<v8::Value> jsHiddenPanels(const v8::Arguments& args); + static v8::Handle<v8::Value> jsDebuggerCommand(const v8::Arguments& args); + static v8::Handle<v8::Value> jsSetting(const v8::Arguments& args); + static v8::Handle<v8::Value> jsSetSetting(const v8::Arguments& args); + static v8::Handle<v8::Value> jsDebuggerPauseScript(const v8::Arguments& args); + static v8::Handle<v8::Value> jsWindowUnloading(const v8::Arguments& args); + static v8::Handle<v8::Value> jsShowContextMenu(const v8::Arguments& args); + + WebKit::WebViewImpl* m_webViewImpl; + WebKit::WebDevToolsFrontendClient* m_client; + String m_applicationLocale; + OwnPtr<JSDebuggerAgentBoundObj> m_debuggerAgentObj; + OwnPtr<JSProfilerAgentBoundObj> m_profilerAgentObj; + OwnPtr<JSToolsAgentBoundObj> m_toolsAgentObj; + bool m_loaded; + Vector<Vector<String> > m_pendingIncomingMessages; + RefPtr<MenuProvider> m_menuProvider; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/WebDocument.cpp b/WebKit/chromium/src/WebDocument.cpp new file mode 100644 index 0000000..84f3004 --- /dev/null +++ b/WebKit/chromium/src/WebDocument.cpp @@ -0,0 +1,150 @@ +/* + * 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 "WebDocument.h" + +#include "Document.h" +#include "DocumentLoader.h" +#include "Element.h" +#include "HTMLAllCollection.h" +#include "HTMLBodyElement.h" +#include "HTMLCollection.h" +#include "HTMLElement.h" +#include "HTMLHeadElement.h" +#include "NodeList.h" + +#include "WebElement.h" +#include "WebFrameImpl.h" +#include "WebNodeCollection.h" +#include "WebURL.h" + +#include <wtf/PassRefPtr.h> + +using namespace WebCore; + +namespace WebKit { + +WebDocument::WebDocument(const PassRefPtr<Document>& elem) + : WebNode(elem.releaseRef()) +{ +} + +WebDocument& WebDocument::operator=(const PassRefPtr<Document>& elem) +{ + WebNode::assign(elem.releaseRef()); + return *this; +} + +WebDocument::operator PassRefPtr<Document>() const +{ + return PassRefPtr<Document>(static_cast<Document*>(m_private)); +} + +WebFrame* WebDocument::frame() const +{ + return WebFrameImpl::fromFrame(constUnwrap<Document>()->frame()); +} + +bool WebDocument::isHTMLDocument() const +{ + return constUnwrap<Document>()->isHTMLDocument(); +} + +WebURL WebDocument::baseURL() const +{ + return constUnwrap<Document>()->baseURL(); +} + +WebElement WebDocument::documentElement() const +{ + return WebElement(constUnwrap<Document>()->documentElement()); +} + +WebElement WebDocument::body() const +{ + return WebElement(constUnwrap<Document>()->body()); +} + +WebElement WebDocument::head() +{ + return WebElement(unwrap<Document>()->head()); +} + +WebNodeCollection WebDocument::all() +{ + return WebNodeCollection(unwrap<Document>()->all()); +} + +WebURL WebDocument::completeURL(const WebString& partialURL) const +{ + return constUnwrap<Document>()->completeURL(partialURL); +} + +WebElement WebDocument::getElementById(const WebString& id) const +{ + return WebElement(constUnwrap<Document>()->getElementById(id)); +} + +WebString WebDocument::applicationID() const +{ + const char* kChromeApplicationHeader = "x-chrome-application"; + + // First check if the document's response included a header indicating the + // application it should go with. + const Document* document = constUnwrap<Document>(); + Frame* frame = document->frame(); + if (!frame) + return WebString(); + + DocumentLoader* loader = frame->loader()->documentLoader(); + if (!loader) + return WebString(); + + WebString headerValue = + loader->response().httpHeaderField(kChromeApplicationHeader); + if (!headerValue.isEmpty()) + return headerValue; + + // Otherwise, fall back to looking for the meta tag. + RefPtr<NodeList> metaTags = + const_cast<Document*>(document)->getElementsByTagName("meta"); + for (unsigned i = 0; i < metaTags->length(); ++i) { + Element* element = static_cast<Element*>(metaTags->item(i)); + if (element->getAttribute("http-equiv").lower() == + kChromeApplicationHeader) { + return element->getAttribute("value"); + } + } + + return WebString(); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebDragData.cpp b/WebKit/chromium/src/WebDragData.cpp new file mode 100644 index 0000000..b18ab1b --- /dev/null +++ b/WebKit/chromium/src/WebDragData.cpp @@ -0,0 +1,243 @@ +/* + * 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; +} + +WebURL WebDragData::downloadURL() const +{ + ASSERT(!isNull()); + return m_private->downloadURL; +} + +void WebDragData::setDownloadURL(const WebURL& downloadURL) +{ + ensureMutable(); + m_private->downloadURL = downloadURL; +} + +WebString WebDragData::downloadMetadata() const +{ + ASSERT(!isNull()); + return m_private->downloadMetadata; +} + +void WebDragData::setDownloadMetadata(const WebString& downloadMetadata) +{ + ensureMutable(); + m_private->downloadMetadata = downloadMetadata; +} + +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..d0a0862 --- /dev/null +++ b/WebKit/chromium/src/WebElement.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: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (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)); +} + +WebString WebElement::tagName() const +{ + return constUnwrap<Element>()->tagName(); +} + +bool WebElement::hasTagName(const WebString& tagName) const +{ + return equalIgnoringCase(constUnwrap<Element>()->tagName(), + tagName.operator WebCore::String()); +} + +bool WebElement::hasAttribute(const WebString& attrName) const +{ + return constUnwrap<Element>()->hasAttribute(attrName); +} + +WebString WebElement::getAttribute(const WebString& attrName) const +{ + return constUnwrap<Element>()->getAttribute(attrName); +} + +bool WebElement::setAttribute(const WebString& attrName, const WebString& attrValue) +{ + ExceptionCode exceptionCode = 0; + unwrap<Element>()->setAttribute(attrName, attrValue, exceptionCode); + return !exceptionCode; +} + +WebString WebElement::innerText() const +{ + return constUnwrap<Element>()->innerText(); +} + +} // namespace WebKit + diff --git a/WebKit/chromium/src/WebEntities.cpp b/WebKit/chromium/src/WebEntities.cpp new file mode 100644 index 0000000..b9143d9 --- /dev/null +++ b/WebKit/chromium/src/WebEntities.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 "WebEntities.h" + +#include <string.h> + +#include "PlatformString.h" +#include "StringBuilder.h" +#include <wtf/HashMap.h> + +#include "WebString.h" + +using namespace WebCore; + +namespace { +// Note that this file is also included by HTMLTokenizer.cpp so we are getting +// two copies of the data in memory. We can fix this by changing the script +// that generated the array to create a static const that is its length, but +// this is low priority since the data is less than 4K. We use anonymous +// namespace to prevent name collisions. +#include "HTMLEntityNames.c" // NOLINT +} + +namespace WebKit { + +void populateMap(WTF::HashMap<int, WebCore::String>& map, + const Entity* entities, + size_t entitiesCount, + bool standardHTML) +{ + ASSERT(map.isEmpty()); + const Entity* entity = &entities[0]; + for (size_t i = 0; i < entitiesCount; i++, entity++) { + int code = entity->code; + String name = entity->name; + // For consistency, use the lowe case for entities that have both. + if (map.contains(code) && map.get(code) == name.lower()) + continue; + // Don't register %, ⊅ and &supl;. + if (standardHTML && (code == '%' || code == 0x2285 || code == 0x00b9)) + continue; + map.set(code, name); + } + if (standardHTML) + map.set(static_cast<int>(0x0027), String("#39")); +} + +static const Entity xmlBuiltInEntityCodes[] = { + { "lt", 0x003c }, + { "gt", 0x003e }, + { "amp", 0x0026 }, + { "apos", 0x0027 }, + { "quot", 0x0022 } +}; + +WebEntities::WebEntities(bool xmlEntities) +{ + if (xmlEntities) + populateMap(m_entitiesMap, + xmlBuiltInEntityCodes, + sizeof(xmlBuiltInEntityCodes) / sizeof(Entity), + false); + else + populateMap(m_entitiesMap, + wordlist, + sizeof(wordlist) / sizeof(Entity), + true); +} + +String WebEntities::entityNameByCode(int code) const +{ + if (m_entitiesMap.contains(code)) + return m_entitiesMap.get(code); + return ""; +} + +String WebEntities::convertEntitiesInString(const String& value) const +{ + unsigned len = value.length(); + const UChar* startPos = value.characters(); + const UChar* curPos = startPos; + + // FIXME: Optimize - create StringBuilder only if value has any entities. + StringBuilder result; + while (len--) { + if (m_entitiesMap.contains(*curPos)) { + // Append content before entity code. + if (curPos > startPos) + result.append(String(startPos, curPos - startPos)); + result.append("&"); + result.append(m_entitiesMap.get(*curPos)); + result.append(";"); + startPos = ++curPos; + } else + curPos++; + } + // Append the remaining content. + if (curPos > startPos) + result.append(String(startPos, curPos - startPos)); + + return result.toString(); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebEntities.h b/WebKit/chromium/src/WebEntities.h new file mode 100644 index 0000000..ad3c310 --- /dev/null +++ b/WebKit/chromium/src/WebEntities.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 WebEntities_h +#define WebEntities_h + +#include "PlatformString.h" +#include <wtf/HashMap.h> + +namespace WebKit { + +class WebEntities { +public: + // ', %, ⊅, &supl; are not defined by the HTML standards. + // - IE does not support ' as an HTML entity (but support it as an XML + // entity.) + // - Firefox supports ' as an HTML entity. + // - Both of IE and Firefox don't support %, ⊅ and &supl;. + // + // A web page saved by Chromium should be able to be read by other browsers + // such as IE and Firefox. Chromium should produce only the standard entity + // references which other browsers can recognize. + // So if standard_html_entities_ is true, we will use a numeric character + // reference for ', and don't use entity references for %, ⊅ + // and &supl; for serialization. + // + // If xmlEntities is true, WebEntities will only contain standard XML + // entities. + explicit WebEntities(bool xmlEntities); + + // Check whether specified unicode has corresponding html or xml built-in + // entity name. If yes, return the entity notation. If not, returns an + // empty string. Parameter isHTML indicates check the code in html entity + // map or in xml entity map. + WebCore::String entityNameByCode(int code) const; + + // Returns a new string with corresponding entity names replaced. + WebCore::String convertEntitiesInString(const WebCore::String&) const; +private: + typedef HashMap<int, WebCore::String> EntitiesMapType; + // An internal object that maps the Unicode character to corresponding + // entity notation. + EntitiesMapType m_entitiesMap; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/WebEvent.cpp b/WebKit/chromium/src/WebEvent.cpp new file mode 100644 index 0000000..8c68959 --- /dev/null +++ b/WebKit/chromium/src/WebEvent.cpp @@ -0,0 +1,219 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebEvent.h" + +#include "Event.h" +#include "Node.h" +#include <wtf/PassRefPtr.h> + +namespace WebKit { + +class WebEventPrivate : public WebCore::Event { +}; + +void WebEvent::reset() +{ + assign(0); +} + +void WebEvent::assign(const WebEvent& other) +{ + WebEventPrivate* p = const_cast<WebEventPrivate*>(other.m_private); + if (p) + p->ref(); + assign(p); +} + +void WebEvent::assign(WebEventPrivate* p) +{ + // p is already ref'd for us by the caller + if (m_private) + m_private->deref(); + m_private = p; +} + +WebEvent::WebEvent(const WTF::PassRefPtr<WebCore::Event>& event) + : m_private(static_cast<WebEventPrivate*>(event.releaseRef())) +{ +} + +WebString WebEvent::type() const +{ + ASSERT(m_private); + return m_private->type(); +} + +WebNode WebEvent::target() const +{ + ASSERT(m_private); + return WebNode(m_private->target()->toNode()); +} + +WebNode WebEvent::currentTarget() const +{ + ASSERT(m_private); + return WebNode(m_private->currentTarget()->toNode()); +} + +WebEvent::PhaseType WebEvent::eventPhase() const +{ + ASSERT(m_private); + return static_cast<WebEvent::PhaseType>(m_private->eventPhase()); +} + +bool WebEvent::bubbles() const +{ + ASSERT(m_private); + return m_private->bubbles(); +} + +bool WebEvent::cancelable() const +{ + ASSERT(m_private); + return m_private->cancelable(); +} + +bool WebEvent::isUIEvent() const +{ + ASSERT(m_private); + return m_private->isUIEvent(); +} + +bool WebEvent::isMouseEvent() const +{ + ASSERT(m_private); + return m_private->isMouseEvent(); +} + +bool WebEvent::isMutationEvent() const +{ + ASSERT(m_private); + return m_private->isMutationEvent(); +} + +bool WebEvent::isKeyboardEvent() const +{ + ASSERT(m_private); + return m_private->isKeyboardEvent(); +} + +bool WebEvent::isTextEvent() const +{ + ASSERT(m_private); + return m_private->isTextEvent(); +} + +bool WebEvent::isCompositionEvent() const +{ + ASSERT(m_private); + return m_private->isCompositionEvent(); +} + +bool WebEvent::isDragEvent() const +{ + ASSERT(m_private); + return m_private->isDragEvent(); +} + +bool WebEvent::isClipboardEvent() const +{ + ASSERT(m_private); + return m_private->isClipboardEvent(); +} + +bool WebEvent::isMessageEvent() const +{ + ASSERT(m_private); + return m_private->isMessageEvent(); +} + +bool WebEvent::isWheelEvent() const +{ + ASSERT(m_private); + return m_private->isWheelEvent(); +} + +bool WebEvent::isBeforeTextInsertedEvent() const +{ + ASSERT(m_private); + return m_private->isBeforeTextInsertedEvent(); +} + +bool WebEvent::isOverflowEvent() const +{ + ASSERT(m_private); + return m_private->isOverflowEvent(); +} + +bool WebEvent::isPageTransitionEvent() const +{ + ASSERT(m_private); + return m_private->isPageTransitionEvent(); +} + +bool WebEvent::isPopStateEvent() const +{ + ASSERT(m_private); + return m_private->isPopStateEvent(); +} + +bool WebEvent::isProgressEvent() const +{ + ASSERT(m_private); + return m_private->isProgressEvent(); +} + +bool WebEvent::isXMLHttpRequestProgressEvent() const +{ + ASSERT(m_private); + return m_private->isXMLHttpRequestProgressEvent(); +} + +bool WebEvent::isWebKitAnimationEvent() const +{ + ASSERT(m_private); + return m_private->isWebKitAnimationEvent(); +} + +bool WebEvent::isWebKitTransitionEvent() const +{ + ASSERT(m_private); + return m_private->isWebKitTransitionEvent(); +} + +bool WebEvent::isBeforeLoadEvent() const +{ + ASSERT(m_private); + return m_private->isBeforeLoadEvent(); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebEventListener.cpp b/WebKit/chromium/src/WebEventListener.cpp new file mode 100644 index 0000000..8d9a887 --- /dev/null +++ b/WebKit/chromium/src/WebEventListener.cpp @@ -0,0 +1,64 @@ +/*
+ * Copyright (C) 2010 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "WebEventListener.h"
+
+#include "WebEventListenerPrivate.h"
+
+namespace WebKit {
+
+WebEventListener::WebEventListener()
+ : m_private(new WebEventListenerPrivate(this))
+{
+}
+
+WebEventListener::~WebEventListener()
+{
+ m_private->webEventListenerDeleted();
+ delete m_private;
+}
+
+void WebEventListener::notifyEventListenerDeleted(EventListenerWrapper* wrapper)
+{
+ m_private->eventListenerDeleted(wrapper);
+}
+
+EventListenerWrapper* WebEventListener::createEventListenerWrapper(const WebString& eventType, bool useCapture, Node* node)
+{
+ return m_private->createEventListenerWrapper(eventType, useCapture, node);
+}
+
+EventListenerWrapper* WebEventListener::getEventListenerWrapper(const WebString& eventType, bool useCapture, Node* node)
+{
+ return m_private->getEventListenerWrapper(eventType, useCapture, node);
+}
+
+} // namespace WebKit
diff --git a/WebKit/chromium/src/WebEventListenerPrivate.cpp b/WebKit/chromium/src/WebEventListenerPrivate.cpp new file mode 100644 index 0000000..bd14baf --- /dev/null +++ b/WebKit/chromium/src/WebEventListenerPrivate.cpp @@ -0,0 +1,87 @@ +/*
+ * Copyright (C) 2010 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "WebEventListenerPrivate.h"
+
+#include "EventListenerWrapper.h"
+#include "WebEventListener.h"
+
+namespace WebKit {
+
+WebEventListenerPrivate::WebEventListenerPrivate(WebEventListener* webEventListener)
+ : m_webEventListener(webEventListener)
+{
+}
+
+WebEventListenerPrivate::~WebEventListenerPrivate()
+{
+}
+
+EventListenerWrapper* WebEventListenerPrivate::createEventListenerWrapper(const WebString& eventType, bool useCapture, Node* node)
+{
+ EventListenerWrapper* listenerWrapper = new EventListenerWrapper(m_webEventListener);
+ WebEventListenerPrivate::ListenerInfo listenerInfo(eventType, useCapture, listenerWrapper, node);
+ m_listenerWrappers.append(listenerInfo);
+ return listenerWrapper;
+}
+
+EventListenerWrapper* WebEventListenerPrivate::getEventListenerWrapper(const WebString& eventType, bool useCapture, Node* node)
+{
+ Vector<WebEventListenerPrivate::ListenerInfo>::const_iterator iter;
+ for (iter = m_listenerWrappers.begin(); iter != m_listenerWrappers.end(); ++iter) {
+ if (iter->node == node)
+ return iter->eventListenerWrapper;
+ }
+ ASSERT_NOT_REACHED();
+ return 0;
+}
+
+void WebEventListenerPrivate::webEventListenerDeleted()
+{
+ // Notifies all WebEventListenerWrappers that we are going away so they can
+ // invalidate their pointer to us.
+ Vector<WebEventListenerPrivate::ListenerInfo>::const_iterator iter;
+ for (iter = m_listenerWrappers.begin(); iter != m_listenerWrappers.end(); ++iter)
+ iter->eventListenerWrapper->webEventListenerDeleted();
+}
+
+void WebEventListenerPrivate::eventListenerDeleted(EventListenerWrapper* eventListener)
+{
+ for (size_t i = 0; i < m_listenerWrappers.size(); ++i) {
+ if (m_listenerWrappers[i].eventListenerWrapper == eventListener) {
+ m_listenerWrappers.remove(i);
+ return;
+ }
+ }
+ ASSERT_NOT_REACHED();
+}
+
+} // namespace WebKit
diff --git a/WebKit/chromium/src/WebEventListenerPrivate.h b/WebKit/chromium/src/WebEventListenerPrivate.h new file mode 100644 index 0000000..0ba2b5d --- /dev/null +++ b/WebKit/chromium/src/WebEventListenerPrivate.h @@ -0,0 +1,95 @@ +/*
+ * Copyright (C) 2010 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef WebEventListenerPrivate_h
+#define WebEventListenerPrivate_h
+
+#include "WebString.h"
+
+#include <wtf/Vector.h>
+
+namespace WebCore {
+class Node;
+}
+
+using namespace WebCore;
+
+namespace WebKit {
+
+class EventListenerWrapper;
+class WebEventListener;
+
+class WebEventListenerPrivate {
+public:
+ WebEventListenerPrivate(WebEventListener* webEventListener);
+ ~WebEventListenerPrivate();
+
+ EventListenerWrapper* createEventListenerWrapper(
+ const WebString& eventType, bool useCapture, Node* node);
+
+ // Gets the ListenerEventWrapper for a specific node.
+ // Used by WebNode::removeEventListener().
+ EventListenerWrapper* getEventListenerWrapper(
+ const WebString& eventType, bool useCapture, Node* node);
+
+ // Called by the WebEventListener when it is about to be deleted.
+ void webEventListenerDeleted();
+
+ // Called by the EventListenerWrapper when it is about to be deleted.
+ void eventListenerDeleted(EventListenerWrapper* eventListener);
+
+ struct ListenerInfo {
+ ListenerInfo(const WebString& eventType, bool useCapture,
+ EventListenerWrapper* eventListenerWrapper,
+ Node* node)
+ : eventType(eventType)
+ , useCapture(useCapture)
+ , eventListenerWrapper(eventListenerWrapper)
+ , node(node)
+ {
+ }
+
+ WebString eventType;
+ bool useCapture;
+ EventListenerWrapper* eventListenerWrapper;
+ Node* node;
+ };
+
+private:
+ WebEventListener* m_webEventListener;
+
+ // We keep a list of the wrapper for the WebKit EventListener, it is needed
+ // to implement WebNode::removeEventListener().
+ Vector<ListenerInfo> m_listenerWrappers;
+};
+
+} // namespace WebKit
+
+#endif
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..2f911f1 --- /dev/null +++ b/WebKit/chromium/src/WebFrameImpl.cpp @@ -0,0 +1,2004 @@ +/* + * 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 "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 "RenderTreeAsText.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 "WebAnimationControllerImpl.h" +#include "WebConsoleMessage.h" +#include "WebDataSourceImpl.h" +#include "WebDocument.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 OS(DARWIN) +#include "LocalCurrentGraphicsContext.h" +#endif + +#if OS(LINUX) +#include <gdk/gdk.h> +#endif + +using namespace WebCore; + +namespace WebKit { + +static int frameCount = 0; + +// 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 ------------------------------------------------------------------- + +int WebFrame::instanceCount() +{ + return frameCount; +} + +WebFrame* WebFrame::frameForEnteredContext() +{ + Frame* frame = + ScriptController::retrieveFrameForEnteredContext(); + return WebFrameImpl::fromFrame(frame); +} + +WebFrame* WebFrame::frameForCurrentContext() +{ + Frame* frame = + ScriptController::retrieveFrameForCurrentContext(); + return WebFrameImpl::fromFrame(frame); +} + +WebFrame* WebFrame::fromFrameOwnerElement(const WebElement& element) +{ + return WebFrameImpl::fromFrameOwnerElement( + PassRefPtr<Element>(element).get()); +} + +WebString WebFrameImpl::name() const +{ + return m_frame->tree()->name(); +} + +void WebFrameImpl::clearName() +{ + m_frame->tree()->clearName(); +} + +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(); +} + +WebString WebFrameImpl::encoding() const +{ + return frame()->loader()->encoding(); +} + +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()); +} + +WebDocument WebFrameImpl::document() const +{ + if (!m_frame || !m_frame->document()) + return WebDocument(); + return WebDocument(m_frame->document()); +} + +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); +} + +WebAnimationController* WebFrameImpl::animationController() +{ + return &m_animationController; +} + +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()->canExecuteScripts()) + 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::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 OS(WINDOWS) + 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); +} + +void WebFrameImpl::selectWordAroundPosition(Frame* frame, VisiblePosition pos) +{ + VisibleSelection selection(pos); + selection.expandUsingGranularity(WordGranularity); + + if (selection.isRange()) + frame->setSelectionGranularity(WordGranularity); + + if (frame->shouldChangeSelection(selection)) + frame->selection()->setSelection(selection); +} + +bool WebFrameImpl::selectWordAroundCaret() +{ + SelectionController* controller = frame()->selection(); + ASSERT(!controller->isNone()); + if (controller->isNone() || controller->isRange()) + return false; + selectWordAroundPosition(frame(), controller->selection().visibleStart()); + return true; +} + +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 OS(WINDOWS) || OS(LINUX) || OS(FREEBSD) + PlatformContextSkia context(canvas); + GraphicsContext spool(&context); +#elif OS(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. + 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()); +} + +WebString WebFrameImpl::renderTreeAsText() const +{ + return externalRepresentation(m_frame); +} + +WebString WebFrameImpl::counterValueForElementById(const WebString& id) const +{ + if (!m_frame) + return WebString(); + + Element* element = m_frame->document()->getElementById(id); + if (!element) + return WebString(); + + return counterValueForElement(element); +} + +int WebFrameImpl::pageNumberForElementById(const WebString& id, + float pageWidthInPixels, + float pageHeightInPixels) const +{ + if (!m_frame) + return -1; + + Element* element = m_frame->document()->getElementById(id); + if (!element) + return -1; + + FloatSize pageSize(pageWidthInPixels, pageHeightInPixels); + return PrintContext::pageNumberForElement(element, pageSize); +} + +// WebFrameImpl public --------------------------------------------------------- + +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) + , m_animationController(this) +{ + ChromiumBridge::incrementStatsCounter(webFrameActiveCount); + frameCount++; +} + +WebFrameImpl::~WebFrameImpl() +{ + ChromiumBridge::decrementStatsCounter(webFrameActiveCount); + frameCount--; + + 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(); +} + +WebFrameImpl* WebFrameImpl::fromFrameOwnerElement(Element* element) +{ + if (!element + || !element->isFrameOwnerElement() + || (!element->hasTagName(HTMLNames::iframeTag) + && !element->hasTagName(HTMLNames::frameTag))) + return 0; + + HTMLFrameOwnerElement* frameElement = + static_cast<HTMLFrameOwnerElement*>(element); + return fromFrame(frameElement->contentFrame()); +} + +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..ccba6d4 --- /dev/null +++ b/WebKit/chromium/src/WebFrameImpl.h @@ -0,0 +1,366 @@ +/* + * 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> + +#include "WebAnimationControllerImpl.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 void clearName(); + virtual WebURL url() const; + virtual WebURL favIconURL() const; + virtual WebURL openSearchDescriptionURL() const; + virtual WebString encoding() 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 WebDocument document() const; + virtual void forms(WebVector<WebFormElement>&) const; + virtual WebAnimationController* animationController(); + 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 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 bool selectWordAroundCaret(); + 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; + virtual WebString renderTreeAsText() const; + virtual WebString counterValueForElementById(const WebString& id) const; + virtual int pageNumberForElementById(const WebString& id, + float pageWidthInPixels, + float pageHeightInPixels) const; + + static PassRefPtr<WebFrameImpl> create(WebFrameClient* client); + ~WebFrameImpl(); + + // 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); + static WebFrameImpl* fromFrameOwnerElement(WebCore::Element* element); + + 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; } + + static void selectWordAroundPosition(WebCore::Frame*, WebCore::VisiblePosition); + +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&); + + 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; + + // Keeps a reference to the frame's WebAnimationController. + WebAnimationControllerImpl m_animationController; +}; + +} // namespace WebKit + +#endif diff --git a/WebKit/chromium/src/WebGlyphCache.cpp b/WebKit/chromium/src/WebGlyphCache.cpp new file mode 100644 index 0000000..272c6cd --- /dev/null +++ b/WebKit/chromium/src/WebGlyphCache.cpp @@ -0,0 +1,45 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebGlyphCache.h" + +#include "GlyphPageTreeNode.h" + +using namespace WebCore; + +namespace WebKit { + +size_t WebGlyphCache::pageCount() +{ + return GlyphPageTreeNode::treeGlyphPageCount(); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebHTTPBody.cpp b/WebKit/chromium/src/WebHTTPBody.cpp new file mode 100644 index 0000000..3d40869 --- /dev/null +++ b/WebKit/chromium/src/WebHTTPBody.cpp @@ -0,0 +1,164 @@ +/* + * 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" +#include "WebFileInfo.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(); + result.fileStart = 0; + result.fileLength = 0; + result.fileInfo.modificationTime = 0.0; + break; + case FormDataElement::encodedFile: + result.type = Element::TypeFile; + result.data.reset(); + result.filePath = element.m_filename; + result.fileStart = 0; // FIXME: to be set from FormData. + result.fileLength = -1; // FIXME: to be set from FormData. + result.fileInfo.modificationTime = 0.0; // FIXME: to be set from FormData. + 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); +} + +void WebHTTPBody::appendFile(const WebString& filePath, long long fileStart, long long fileLength, const WebFileInfo& fileInfo) +{ + // FIXME: to be implemented. +} + +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..4ca8cc7 --- /dev/null +++ b/WebKit/chromium/src/WebHistoryItem.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 "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); +} + +long long WebHistoryItem::documentSequenceNumber() const +{ + ASSERT(!isNull()); + return m_private->documentSequenceNumber(); +} + +void WebHistoryItem::setDocumentSequenceNumber(long long documentSequenceNumber) +{ + ensureMutable(); + m_private->setDocumentSequenceNumber(documentSequenceNumber); +} + +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..9fd317f --- /dev/null +++ b/WebKit/chromium/src/WebInputElement.cpp @@ -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. + */ + +#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::autoComplete() const +{ + return constUnwrap<HTMLInputElement>()->autoComplete(); +} + +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(); +} + +bool WebInputElement::isActivatedSubmit() const +{ + return constUnwrap<HTMLInputElement>()->isActivatedSubmit(); +} + +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..a8e1851 --- /dev/null +++ b/WebKit/chromium/src/WebKit.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 "WebKit.h" + +#include "AtomicString.h" +#include "DOMTimer.h" +#include "Logging.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 enableLogChannel(const char* name) +{ + WTFLogChannel* channel = WebCore::getChannelFromName(name); + if (channel) + channel->state = WTFLogChannelOn; +} + +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..b1f1f03 --- /dev/null +++ b/WebKit/chromium/src/WebMediaPlayerClientImpl.cpp @@ -0,0 +1,403 @@ +// 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(float newVolume) +{ + ASSERT(m_mediaPlayer); + m_mediaPlayer->volumeChanged(newVolume); +} + +void WebMediaPlayerClientImpl::muteChanged(bool newMute) +{ + ASSERT(m_mediaPlayer); + m_mediaPlayer->muteChanged(newMute); +} + +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..4adbed2 --- /dev/null +++ b/WebKit/chromium/src/WebMediaPlayerClientImpl.h @@ -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. + */ + +#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(float); + virtual void muteChanged(bool); + 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/WebMutationEvent.cpp b/WebKit/chromium/src/WebMutationEvent.cpp new file mode 100644 index 0000000..511b615 --- /dev/null +++ b/WebKit/chromium/src/WebMutationEvent.cpp @@ -0,0 +1,65 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebMutationEvent.h" + +#include "MutationEvent.h" + +using namespace WebCore; + +namespace WebKit { + +WebNode WebMutationEvent::relatedNode() const +{ + return WebNode(constUnwrap<MutationEvent>()->relatedNode()); +} + +WebString WebMutationEvent::prevValue() const +{ + return WebString(constUnwrap<MutationEvent>()->prevValue()); +} + +WebString WebMutationEvent::newValue() const +{ + return WebString(constUnwrap<MutationEvent>()->newValue()); +} + +WebString WebMutationEvent::attrName() const +{ + return WebString(constUnwrap<MutationEvent>()->attrName()); +} + +WebMutationEvent::AttrChangeType WebMutationEvent::attrChange() const +{ + return static_cast<AttrChangeType>(constUnwrap<MutationEvent>()->attrChange()); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebNode.cpp b/WebKit/chromium/src/WebNode.cpp new file mode 100644 index 0000000..9fbf573 --- /dev/null +++ b/WebKit/chromium/src/WebNode.cpp @@ -0,0 +1,197 @@ +/* + * 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 "NodeList.h" + +#include "EventListenerWrapper.h" +#include "WebDocument.h" +#include "WebEvent.h" +#include "WebEventListener.h" +#include "WebFrameImpl.h" +#include "WebNodeList.h" +#include "WebString.h" +#include "WebVector.h" + +#include "markup.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::NodeType WebNode::nodeType() const +{ + return static_cast<NodeType>(m_private->nodeType()); +} + +WebNode WebNode::parentNode() const +{ + return PassRefPtr<Node>(const_cast<Node*>(m_private->parentNode())); +} + +WebString WebNode::nodeName() const +{ + return m_private->nodeName(); +} + +WebString WebNode::nodeValue() const +{ + return m_private->nodeValue(); +} + +bool WebNode::setNodeValue(const WebString& value) +{ + ExceptionCode exceptionCode = 0; + m_private->setNodeValue(value, exceptionCode); + return !exceptionCode; +} + +WebNode::WebNode(const PassRefPtr<Node>& node) + : m_private(static_cast<WebNodePrivate*>(node.releaseRef())) +{ +} + +WebNode& WebNode::operator=(const PassRefPtr<Node>& node) +{ + assign(static_cast<WebNodePrivate*>(node.releaseRef())); + return *this; +} + +WebNode::operator PassRefPtr<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()); +} + +WebDocument WebNode::document() const +{ + return WebDocument(m_private->document()); +} + +WebNode WebNode::firstChild() const +{ + return WebNode(m_private->firstChild()); +} + +WebNode WebNode::lastChild() const +{ + return WebNode(m_private->lastChild()); +} + +WebNode WebNode::previousSibling() const +{ + return WebNode(m_private->previousSibling()); +} + +WebNode WebNode::nextSibling() const +{ + return WebNode(m_private->nextSibling()); +} + +bool WebNode::hasChildNodes() const +{ + return m_private->hasChildNodes(); +} + +WebNodeList WebNode::childNodes() +{ + return WebNodeList(m_private->childNodes()); +} + +WebString WebNode::createMarkup() const +{ + return WebCore::createMarkup(m_private); +} + +bool WebNode::isTextNode() const +{ + return m_private->isTextNode(); +} + +bool WebNode::isElementNode() const +{ + return m_private->isElementNode(); +} + +void WebNode::addEventListener(const WebString& eventType, WebEventListener* listener, bool useCapture) +{ + EventListenerWrapper* listenerWrapper = + listener->createEventListenerWrapper(eventType, useCapture, m_private); + // The listenerWrapper is only referenced by the actual Node. Once it goes + // away, the wrapper notifies the WebEventListener so it can clear its + // pointer to it. + m_private->addEventListener(eventType, adoptRef(listenerWrapper), useCapture); +} + +void WebNode::removeEventListener(const WebString& eventType, WebEventListener* listener, bool useCapture) +{ + EventListenerWrapper* listenerWrapper = + listener->getEventListenerWrapper(eventType, useCapture, m_private); + m_private->removeEventListener(eventType, listenerWrapper, useCapture); + // listenerWrapper is now deleted. +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebNodeCollection.cpp b/WebKit/chromium/src/WebNodeCollection.cpp new file mode 100644 index 0000000..a9e532f --- /dev/null +++ b/WebKit/chromium/src/WebNodeCollection.cpp @@ -0,0 +1,85 @@ +/* + * 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 "WebNodeCollection.h" + +#include "HTMLCollection.h" +#include "Node.h" +#include <wtf/PassRefPtr.h> + +#include "WebNode.h" + +using namespace WebCore; + +namespace WebKit { + +void WebNodeCollection::reset() +{ + assign(0); +} + +void WebNodeCollection::assign(const WebNodeCollection& other) +{ + HTMLCollection* p = const_cast<HTMLCollection*>(other.m_private); + if (p) + p->ref(); + assign(p); +} + +WebNodeCollection::WebNodeCollection(const PassRefPtr<HTMLCollection>& col) + : m_private(static_cast<HTMLCollection*>(col.releaseRef())) +{ +} + +void WebNodeCollection::assign(HTMLCollection* p) +{ + // p is already ref'd for us by the caller + if (m_private) + m_private->deref(); + m_private = p; +} + +unsigned WebNodeCollection::length() const +{ + return m_private->length(); +} + +WebNode WebNodeCollection::nextItem() const +{ + return WebNode(m_private->nextItem()); +} + +WebNode WebNodeCollection::firstItem() const +{ + return WebNode(m_private->firstItem()); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebNodeList.cpp b/WebKit/chromium/src/WebNodeList.cpp new file mode 100644 index 0000000..f68f961 --- /dev/null +++ b/WebKit/chromium/src/WebNodeList.cpp @@ -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. + */ + +#include "config.h" +#include "WebNodeList.h" + +#include "Node.h" +#include "NodeList.h" +#include <wtf/PassRefPtr.h> + +#include "WebNode.h" + +using namespace WebCore; + +namespace WebKit { + +void WebNodeList::reset() +{ + assign(0); +} + +void WebNodeList::assign(const WebNodeList& other) +{ + NodeList* p = const_cast<NodeList*>(other.m_private); + if (p) + p->ref(); + assign(p); +} + +WebNodeList::WebNodeList(const PassRefPtr<NodeList>& col) + : m_private(static_cast<NodeList*>(col.releaseRef())) +{ +} + +void WebNodeList::assign(NodeList* p) +{ + // p is already ref'd for us by the caller + if (m_private) + m_private->deref(); + m_private = p; +} + +unsigned WebNodeList::length() const +{ + return m_private->length(); +} + +WebNode WebNodeList::item(size_t index) const +{ + return WebNode(m_private->item(index)); +} + +} // 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/WebPageSerializer.cpp b/WebKit/chromium/src/WebPageSerializer.cpp new file mode 100644 index 0000000..1010285 --- /dev/null +++ b/WebKit/chromium/src/WebPageSerializer.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: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (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 "WebPageSerializer.h" + +#include "KURL.h" +#include "PlatformString.h" + +#include "WebFrame.h" +#include "WebPageSerializerClient.h" +#include "WebPageSerializerImpl.h" +#include "WebString.h" +#include "WebURL.h" +#include "WebVector.h" + +using namespace WebCore; + +namespace WebKit { + +bool WebPageSerializer::serialize(WebFrame* frame, + bool recursive, + WebPageSerializerClient* client, + const WebVector<WebURL>& links, + const WebVector<WebString>& localPaths, + const WebString& localDirectoryName) +{ + WebPageSerializerImpl serializerImpl( + frame, recursive, client, links, localPaths, localDirectoryName); + return serializerImpl.serialize(); +} + +WebString WebPageSerializer::generateMetaCharsetDeclaration(const WebString& charset) +{ + return String::format("<META http-equiv=\"Content-Type\" content=\"text/html; charset=%s\">", + charset.utf8().data()); +} + +WebString WebPageSerializer::generateMarkOfTheWebDeclaration(const WebURL& url) +{ + return String::format("\n<!-- saved from url=(%04d)%s -->\n", + static_cast<int>(url.spec().length()), + url.spec().data()); +} + +WebString WebPageSerializer::generateBaseTagDeclaration(const WebString& baseTarget) +{ + String targetDeclaration; + if (!baseTarget.isEmpty()) + targetDeclaration = String::format(" target=\"%s\"", baseTarget.utf8().data()); + return String::format("<BASE href=\".\"%s>", targetDeclaration.utf8().data()); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebPageSerializerImpl.cpp b/WebKit/chromium/src/WebPageSerializerImpl.cpp new file mode 100644 index 0000000..d5b2b7f --- /dev/null +++ b/WebKit/chromium/src/WebPageSerializerImpl.cpp @@ -0,0 +1,547 @@ +/* + * 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 we handle the base tag better. +// Current status: +// At now the normal way we use to handling base tag is +// a) For those links which have corresponding local saved files, such as +// savable CSS, JavaScript files, they will be written to relative URLs which +// point to local saved file. Why those links can not be resolved as absolute +// file URLs, because if they are resolved as absolute URLs, after moving the +// file location from one directory to another directory, the file URLs will +// be dead links. +// b) For those links which have not corresponding local saved files, such as +// links in A, AREA tags, they will be resolved as absolute URLs. +// c) We comment all base tags when serialzing DOM for the page. +// FireFox also uses above way to handle base tag. +// +// Problem: +// This way can not handle the following situation: +// the base tag is written by JavaScript. +// For example. The page "www.yahoo.com" use +// "document.write('<base href="http://www.yahoo.com/"...');" to setup base URL +// of page when loading page. So when saving page as completed-HTML, we assume +// that we save "www.yahoo.com" to "c:\yahoo.htm". After then we load the saved +// completed-HTML page, then the JavaScript will insert a base tag +// <base href="http://www.yahoo.com/"...> to DOM, so all URLs which point to +// local saved resource files will be resolved as +// "http://www.yahoo.com/yahoo_files/...", which will cause all saved resource +// files can not be loaded correctly. Also the page will be rendered ugly since +// all saved sub-resource files (such as CSS, JavaScript files) and sub-frame +// files can not be fetched. +// Now FireFox, IE and WebKit based Browser all have this problem. +// +// Solution: +// My solution is that we comment old base tag and write new base tag: +// <base href="." ...> after the previous commented base tag. In WebKit, it +// always uses the latest "href" attribute of base tag to set document's base +// URL. Based on this behavior, when we encounter a base tag, we comment it and +// write a new base tag <base href="."> after the previous commented base tag. +// The new added base tag can help engine to locate correct base URL for +// correctly loading local saved resource files. Also I think we need to inherit +// the base target value from document object when appending new base tag. +// If there are multiple base tags in original document, we will comment all old +// base tags and append new base tag after each old base tag because we do not +// know those old base tags are original content or added by JavaScript. If +// they are added by JavaScript, it means when loading saved page, the script(s) +// will still insert base tag(s) to DOM, so the new added base tag(s) can +// override the incorrect base URL and make sure we alway load correct local +// saved resource files. + +#include "config.h" +#include "WebPageSerializerImpl.h" + +#include "Document.h" +#include "DocumentType.h" +#include "Element.h" +#include "FrameLoader.h" +#include "HTMLAllCollection.h" +#include "HTMLElement.h" +#include "HTMLFormElement.h" +#include "HTMLMetaElement.h" +#include "HTMLNames.h" +#include "KURL.h" +#include "PlatformString.h" +#include "StringBuilder.h" +#include "TextEncoding.h" +#include "markup.h" + +#include "DOMUtilitiesPrivate.h" +#include "WebFrameImpl.h" +#include "WebURL.h" +#include "WebVector.h" + +using namespace WebCore; + +namespace WebKit { + +// Maximum length of data buffer which is used to temporary save generated +// html content data. This is a soft limit which might be passed if a very large +// contegious string is found in the page. +static const unsigned dataBufferCapacity = 65536; + +WebPageSerializerImpl::SerializeDomParam::SerializeDomParam(const KURL& currentFrameURL, + const TextEncoding& textEncoding, + Document* doc, + const String& directoryName) + : currentFrameURL(currentFrameURL) + , textEncoding(textEncoding) + , doc(doc) + , directoryName(directoryName) + , hasDoctype(false) + , hasCheckedMeta(false) + , skipMetaElement(0) + , isInScriptOrStyleTag(false) + , hasDocDeclaration(false) +{ + // Cache the value since we check it lots of times. + isHTMLDocument = doc->isHTMLDocument(); +} + +String WebPageSerializerImpl::preActionBeforeSerializeOpenTag( + const Element* element, SerializeDomParam* param, bool* needSkip) +{ + StringBuilder result; + + *needSkip = false; + if (param->isHTMLDocument) { + // Skip the open tag of original META tag which declare charset since we + // have overrided the META which have correct charset declaration after + // serializing open tag of HEAD element. + if (element->hasTagName(HTMLNames::metaTag)) { + const HTMLMetaElement* meta = static_cast<const HTMLMetaElement*>(element); + // Check whether the META tag has declared charset or not. + String equiv = meta->httpEquiv(); + if (equalIgnoringCase(equiv, "content-type")) { + String content = meta->content(); + if (content.length() && content.contains("charset", false)) { + // Find META tag declared charset, we need to skip it when + // serializing DOM. + param->skipMetaElement = element; + *needSkip = true; + } + } + } else if (element->hasTagName(HTMLNames::htmlTag)) { + // Check something before processing the open tag of HEAD element. + // First we add doc type declaration if original doc has it. + if (!param->hasDoctype) { + param->hasDoctype = true; + result.append(createMarkup(param->doc->doctype())); + } + + // Add MOTW declaration before html tag. + // See http://msdn2.microsoft.com/en-us/library/ms537628(VS.85).aspx. + result.append(WebPageSerializer::generateMarkOfTheWebDeclaration(param->currentFrameURL)); + } else if (element->hasTagName(HTMLNames::baseTag)) { + // Comment the BASE tag when serializing dom. + result.append("<!--"); + } + } else { + // Write XML declaration. + if (!param->hasDocDeclaration) { + param->hasDocDeclaration = true; + // Get encoding info. + String xmlEncoding = param->doc->xmlEncoding(); + if (xmlEncoding.isEmpty()) + xmlEncoding = param->doc->frame()->loader()->encoding(); + if (xmlEncoding.isEmpty()) + xmlEncoding = UTF8Encoding().name(); + result.append("<?xml version=\""); + result.append(param->doc->xmlVersion()); + result.append("\" encoding=\""); + result.append(xmlEncoding); + if (param->doc->xmlStandalone()) + result.append("\" standalone=\"yes"); + result.append("\"?>\n"); + } + // Add doc type declaration if original doc has it. + if (!param->hasDoctype) { + param->hasDoctype = true; + result.append(createMarkup(param->doc->doctype())); + } + } + return result.toString(); +} + +String WebPageSerializerImpl::postActionAfterSerializeOpenTag( + const Element* element, SerializeDomParam* param) +{ + StringBuilder result; + + param->hasAddedContentsBeforeEnd = false; + if (!param->isHTMLDocument) + return result.toString(); + // Check after processing the open tag of HEAD element + if (!param->hasCheckedMeta + && element->hasTagName(HTMLNames::headTag)) { + param->hasCheckedMeta = true; + // Check meta element. WebKit only pre-parse the first 512 bytes + // of the document. If the whole <HEAD> is larger and meta is the + // end of head part, then this kind of pages aren't decoded correctly + // because of this issue. So when we serialize the DOM, we need to + // make sure the meta will in first child of head tag. + // See http://bugs.webkit.org/show_bug.cgi?id=16621. + // First we generate new content for writing correct META element. + result.append(WebPageSerializer::generateMetaCharsetDeclaration( + String(param->textEncoding.name()))); + + param->hasAddedContentsBeforeEnd = true; + // Will search each META which has charset declaration, and skip them all + // in PreActionBeforeSerializeOpenTag. + } else if (element->hasTagName(HTMLNames::scriptTag) + || element->hasTagName(HTMLNames::styleTag)) { + param->isInScriptOrStyleTag = true; + } + + return result.toString(); +} + +String WebPageSerializerImpl::preActionBeforeSerializeEndTag( + const Element* element, SerializeDomParam* param, bool* needSkip) +{ + String result; + + *needSkip = false; + if (!param->isHTMLDocument) + return result; + // Skip the end tag of original META tag which declare charset. + // Need not to check whether it's META tag since we guarantee + // skipMetaElement is definitely META tag if it's not 0. + if (param->skipMetaElement == element) + *needSkip = true; + else if (element->hasTagName(HTMLNames::scriptTag) + || element->hasTagName(HTMLNames::styleTag)) { + ASSERT(param->isInScriptOrStyleTag); + param->isInScriptOrStyleTag = false; + } + + return result; +} + +// After we finish serializing end tag of a element, we give the target +// element a chance to do some post work to add some additional data. +String WebPageSerializerImpl::postActionAfterSerializeEndTag( + const Element* element, SerializeDomParam* param) +{ + StringBuilder result; + + if (!param->isHTMLDocument) + return result.toString(); + // Comment the BASE tag when serializing DOM. + if (element->hasTagName(HTMLNames::baseTag)) { + result.append("-->"); + // Append a new base tag declaration. + result.append(WebPageSerializer::generateBaseTagDeclaration( + param->doc->baseTarget())); + } + + return result.toString(); +} + +void WebPageSerializerImpl::saveHTMLContentToBuffer( + const String& result, SerializeDomParam* param) +{ + m_dataBuffer.append(result); + encodeAndFlushBuffer(WebPageSerializerClient::CurrentFrameIsNotFinished, + param, + 0); +} + +void WebPageSerializerImpl::encodeAndFlushBuffer( + WebPageSerializerClient::PageSerializationStatus status, + SerializeDomParam* param, + bool force) +{ + // Data buffer is not full nor do we want to force flush. + if (!force && m_dataBuffer.length() <= dataBufferCapacity) + return; + + String content = m_dataBuffer.toString(); + m_dataBuffer.clear(); + + // Convert the unicode content to target encoding + CString encodedContent = param->textEncoding.encode( + content.characters(), content.length(), EntitiesForUnencodables); + + // Send result to the client. + m_client->didSerializeDataForFrame(param->currentFrameURL, + WebCString(encodedContent.data(), encodedContent.length()), + status); +} + +void WebPageSerializerImpl::openTagToString(const Element* element, + SerializeDomParam* param) +{ + // FIXME: use StringBuilder instead of String. + bool needSkip; + // Do pre action for open tag. + String result = preActionBeforeSerializeOpenTag(element, param, &needSkip); + if (needSkip) + return; + // Add open tag + result += "<" + element->nodeName(); + // Go through all attributes and serialize them. + const NamedNodeMap *attrMap = element->attributes(true); + if (attrMap) { + unsigned numAttrs = attrMap->length(); + for (unsigned i = 0; i < numAttrs; i++) { + result += " "; + // Add attribute pair + const Attribute *attribute = attrMap->attributeItem(i); + result += attribute->name().toString(); + result += "=\""; + if (!attribute->value().isEmpty()) { + const String& attrValue = attribute->value(); + + // Check whether we need to replace some resource links + // with local resource paths. + const QualifiedName& attrName = attribute->name(); + if (elementHasLegalLinkAttribute(element, attrName)) { + // For links start with "javascript:", we do not change it. + if (attrValue.startsWith("javascript:", false)) + result += attrValue; + else { + // Get the absolute link + String completeURL = param->doc->completeURL(attrValue); + // Check whether we have local files for those link. + if (m_localLinks.contains(completeURL)) { + if (!m_localDirectoryName.isEmpty()) + result += "./" + m_localDirectoryName + "/"; + result += m_localLinks.get(completeURL); + } else + result += completeURL; + } + } else { + if (param->isHTMLDocument) + result += m_htmlEntities.convertEntitiesInString(attrValue); + else + result += m_xmlEntities.convertEntitiesInString(attrValue); + } + } + result += "\""; + } + } + + // Do post action for open tag. + String addedContents = postActionAfterSerializeOpenTag(element, param); + // Complete the open tag for element when it has child/children. + if (element->hasChildNodes() || param->hasAddedContentsBeforeEnd) + result += ">"; + // Append the added contents generate in post action of open tag. + result += addedContents; + // Save the result to data buffer. + saveHTMLContentToBuffer(result, param); +} + +// Serialize end tag of an specified element. +void WebPageSerializerImpl::endTagToString(const Element* element, + SerializeDomParam* param) +{ + bool needSkip; + // Do pre action for end tag. + String result = preActionBeforeSerializeEndTag(element, + param, + &needSkip); + if (needSkip) + return; + // Write end tag when element has child/children. + if (element->hasChildNodes() || param->hasAddedContentsBeforeEnd) { + result += "</"; + result += element->nodeName(); + result += ">"; + } else { + // Check whether we have to write end tag for empty element. + if (param->isHTMLDocument) { + result += ">"; + const HTMLElement* htmlElement = + static_cast<const HTMLElement*>(element); + if (htmlElement->endTagRequirement() == TagStatusRequired) { + // We need to write end tag when it is required. + result += "</"; + result += element->nodeName(); + result += ">"; + } + } else { + // For xml base document. + result += " />"; + } + } + // Do post action for end tag. + result += postActionAfterSerializeEndTag(element, param); + // Save the result to data buffer. + saveHTMLContentToBuffer(result, param); +} + +void WebPageSerializerImpl::buildContentForNode(const Node* node, + SerializeDomParam* param) +{ + switch (node->nodeType()) { + case Node::ELEMENT_NODE: + // Process open tag of element. + openTagToString(static_cast<const Element*>(node), param); + // Walk through the children nodes and process it. + for (const Node *child = node->firstChild(); child; child = child->nextSibling()) + buildContentForNode(child, param); + // Process end tag of element. + endTagToString(static_cast<const Element*>(node), param); + break; + case Node::TEXT_NODE: + saveHTMLContentToBuffer(createMarkup(node), param); + break; + case Node::ATTRIBUTE_NODE: + case Node::DOCUMENT_NODE: + case Node::DOCUMENT_FRAGMENT_NODE: + // Should not exist. + ASSERT_NOT_REACHED(); + break; + // Document type node can be in DOM? + case Node::DOCUMENT_TYPE_NODE: + param->hasDoctype = true; + default: + // For other type node, call default action. + saveHTMLContentToBuffer(createMarkup(node), param); + break; + } +} + +WebPageSerializerImpl::WebPageSerializerImpl(WebFrame* frame, + bool recursiveSerialization, + WebPageSerializerClient* client, + const WebVector<WebURL>& links, + const WebVector<WebString>& localPaths, + const WebString& localDirectoryName) + : m_client(client) + , m_recursiveSerialization(recursiveSerialization) + , m_framesCollected(false) + , m_localDirectoryName(localDirectoryName) + , m_htmlEntities(false) + , m_xmlEntities(true) +{ + // Must specify available webframe. + ASSERT(frame); + m_specifiedWebFrameImpl = static_cast<WebFrameImpl*>(frame); + // Make sure we have non 0 client. + ASSERT(client); + // Build local resources map. + ASSERT(links.size() == localPaths.size()); + for (size_t i = 0; i < links.size(); i++) { + KURL url = links[i]; + ASSERT(!m_localLinks.contains(url.string())); + m_localLinks.set(url.string(), localPaths[i]); + } + + ASSERT(!m_dataBuffer.length()); +} + +void WebPageSerializerImpl::collectTargetFrames() +{ + ASSERT(!m_framesCollected); + m_framesCollected = true; + + // First, process main frame. + m_frames.append(m_specifiedWebFrameImpl); + // Return now if user only needs to serialize specified frame, not including + // all sub-frames. + if (!m_recursiveSerialization) + return; + // Collect all frames inside the specified frame. + for (int i = 0; i < static_cast<int>(m_frames.size()); ++i) { + WebFrameImpl* currentFrame = m_frames[i]; + // Get current using document. + Document* currentDoc = currentFrame->frame()->document(); + // Go through sub-frames. + RefPtr<HTMLAllCollection> all = currentDoc->all(); + for (Node* node = all->firstItem(); node; node = all->nextItem()) { + if (!node->isHTMLElement()) + continue; + Element* element = static_cast<Element*>(node); + WebFrameImpl* webFrame = + WebFrameImpl::fromFrameOwnerElement(element); + if (webFrame) + m_frames.append(webFrame); + } + } +} + +bool WebPageSerializerImpl::serialize() +{ + // Collect target frames. + if (!m_framesCollected) + collectTargetFrames(); + bool didSerialization = false; + // Get KURL for main frame. + KURL mainPageURL = m_specifiedWebFrameImpl->frame()->loader()->url(); + + // Go through all frames for serializing DOM for whole page, include + // sub-frames. + for (int i = 0; i < static_cast<int>(m_frames.size()); ++i) { + // Get current serializing frame. + WebFrameImpl* currentFrame = m_frames[i]; + // Get current using document. + Document* currentDoc = currentFrame->frame()->document(); + // Get current frame's URL. + const KURL& currentFrameURL = currentFrame->frame()->loader()->url(); + + // Check whether we have done this document. + if (m_localLinks.contains(currentFrameURL.string())) { + // A new document, we will serialize it. + didSerialization = true; + // Get target encoding for current document. + String encoding = currentFrame->frame()->loader()->encoding(); + // Create the text encoding object with target encoding. + TextEncoding textEncoding(encoding); + // Construct serialize parameter for late processing document. + SerializeDomParam param(currentFrameURL, + encoding.length() ? textEncoding : UTF8Encoding(), + currentDoc, + currentFrameURL == mainPageURL ? m_localDirectoryName : ""); + + // Process current document. + Element* rootElement = currentDoc->documentElement(); + if (rootElement) + buildContentForNode(rootElement, ¶m); + + // Flush the remainder data and finish serializing current frame. + encodeAndFlushBuffer(WebPageSerializerClient::CurrentFrameIsFinished, + ¶m, + 1); + } + } + + // We have done call frames, so we send message to embedder to tell it that + // frames are finished serializing. + ASSERT(!m_dataBuffer.length()); + m_client->didSerializeDataForFrame(KURL(), + WebCString("", 0), + WebPageSerializerClient::AllFramesAreFinished); + return didSerialization; +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebPageSerializerImpl.h b/WebKit/chromium/src/WebPageSerializerImpl.h new file mode 100644 index 0000000..8f6a99f --- /dev/null +++ b/WebKit/chromium/src/WebPageSerializerImpl.h @@ -0,0 +1,199 @@ +/* + * 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 WebPageSerializerImpl_h +#define WebPageSerializerImpl_h + +#include "PlatformString.h" +#include "StringBuilder.h" +#include "StringHash.h" +#include <wtf/HashMap.h> +#include <wtf/Vector.h> + +#include "WebEntities.h" +#include "WebPageSerializer.h" +#include "WebPageSerializerClient.h" +#include "WebString.h" +#include "WebURL.h" + +namespace WebCore { +class Document; +class Element; +class Node; +class String; +class TextEncoding; +} + +namespace WebKit { +class WebFrameImpl; + +// Get html data by serializing all frames of current page with lists +// which contain all resource links that have local copy. +// contain all saved auxiliary files included all sub frames and resources. +// This function will find out all frames and serialize them to HTML data. +// We have a data buffer to temporary saving generated html data. We will +// sequentially call WebViewDelegate::SendSerializedHtmlData once the data +// buffer is full. See comments of WebViewDelegate::SendSerializedHtmlData +// for getting more information. +class WebPageSerializerImpl { +public: + // Do serialization action. Return false means no available frame has been + // serialized, otherwise return true. + bool serialize(); + + // The parameter specifies which frame need to be serialized. + // The parameter recursive_serialization specifies whether we need to + // serialize all sub frames of the specified frame or not. + // The parameter delegate specifies the pointer of interface + // DomSerializerDelegate provide sink interface which can receive the + // individual chunks of data to be saved. + // The parameter links contain original URLs of all saved links. + // The parameter local_paths contain corresponding local file paths of all + // saved links, which matched with vector:links one by one. + // The parameter local_directory_name is relative path of directory which + // contain all saved auxiliary files included all sub frames and resources. + WebPageSerializerImpl(WebFrame* frame, + bool recursive, + WebPageSerializerClient* client, + const WebVector<WebURL>& links, + const WebVector<WebString>& localPaths, + const WebString& localDirectoryName); + +private: + // Specified frame which need to be serialized; + WebFrameImpl* m_specifiedWebFrameImpl; + // Pointer of WebPageSerializerClient + WebPageSerializerClient* m_client; + // This hash map is used to map resource URL of original link to its local + // file path. + typedef HashMap<WebCore::String, WebCore::String> LinkLocalPathMap; + // local_links_ include all pair of local resource path and corresponding + // original link. + LinkLocalPathMap m_localLinks; + // Data buffer for saving result of serialized DOM data. + WebCore::StringBuilder m_dataBuffer; + // Passing true to recursive_serialization_ indicates we will serialize not + // only the specified frame but also all sub-frames in the specific frame. + // Otherwise we only serialize the specified frame excluded all sub-frames. + bool m_recursiveSerialization; + // Flag indicates whether we have collected all frames which need to be + // serialized or not; + bool m_framesCollected; + // Local directory name of all local resource files. + WebCore::String m_localDirectoryName; + // Vector for saving all frames which need to be serialized. + Vector<WebFrameImpl*> m_frames; + + // Web entities conversion maps. + WebEntities m_htmlEntities; + WebEntities m_xmlEntities; + + struct SerializeDomParam { + // Frame URL of current processing document presented by GURL + const WebCore::KURL& currentFrameURL; + // Current using text encoding object. + const WebCore::TextEncoding& textEncoding; + + // Document object of current frame. + WebCore::Document* doc; + // Local directory name of all local resource files. + const WebCore::String& directoryName; + + // Flag indicates current doc is html document or not. It's a cache value + // of Document.isHTMLDocument(). + bool isHTMLDocument; + // Flag which indicate whether we have met document type declaration. + bool hasDoctype; + // Flag which indicate whether will process meta issue. + bool hasCheckedMeta; + // This meta element need to be skipped when serializing DOM. + const WebCore::Element* skipMetaElement; + // Flag indicates we are in script or style tag. + bool isInScriptOrStyleTag; + // Flag indicates whether we have written xml document declaration. + // It is only used in xml document + bool hasDocDeclaration; + // Flag indicates whether we have added additional contents before end tag. + // This flag will be re-assigned in each call of function + // PostActionAfterSerializeOpenTag and it could be changed in function + // PreActionBeforeSerializeEndTag if the function adds new contents into + // serialization stream. + bool hasAddedContentsBeforeEnd; + + // Constructor. + SerializeDomParam(const WebCore::KURL& currentFrameURL, + const WebCore::TextEncoding& textEncoding, + WebCore::Document* doc, + const WebCore::String& directoryName); + }; + + // Collect all target frames which need to be serialized. + void collectTargetFrames(); + // Before we begin serializing open tag of a element, we give the target + // element a chance to do some work prior to add some additional data. + WebCore::String preActionBeforeSerializeOpenTag(const WebCore::Element* element, + SerializeDomParam* param, + bool* needSkip); + // After we finish serializing open tag of a element, we give the target + // element a chance to do some post work to add some additional data. + WebCore::String postActionAfterSerializeOpenTag(const WebCore::Element* element, + SerializeDomParam* param); + // Before we begin serializing end tag of a element, we give the target + // element a chance to do some work prior to add some additional data. + WebCore::String preActionBeforeSerializeEndTag(const WebCore::Element* element, + SerializeDomParam* param, + bool* needSkip); + // After we finish serializing end tag of a element, we give the target + // element a chance to do some post work to add some additional data. + WebCore::String postActionAfterSerializeEndTag(const WebCore::Element* element, + SerializeDomParam* param); + // Save generated html content to data buffer. + void saveHTMLContentToBuffer(const WebCore::String& content, + SerializeDomParam* param); + // Flushes the content buffer by encoding and sending the content to the + // WebPageSerializerClient. Content is not flushed if the buffer is not full + // unless force is 1. + void encodeAndFlushBuffer(WebPageSerializerClient::PageSerializationStatus status, + SerializeDomParam* param, + bool force); + // Serialize open tag of an specified element. + void openTagToString(const WebCore::Element* element, + SerializeDomParam* param); + // Serialize end tag of an specified element. + void endTagToString(const WebCore::Element* element, + SerializeDomParam* param); + // Build content for a specified node + void buildContentForNode(const WebCore::Node* node, + SerializeDomParam* param); +}; + +} // namespace WebKit + +#endif 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..86cac26 --- /dev/null +++ b/WebKit/chromium/src/WebPluginContainerImpl.cpp @@ -0,0 +1,557 @@ +/* + * 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 "Chrome.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 !OS(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 !OS(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..ad84764 --- /dev/null +++ b/WebKit/chromium/src/WebRuntimeFeatures.cpp @@ -0,0 +1,187 @@ +/* + * 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 "Database.h" +#include "RuntimeEnabledFeatures.h" +#include "WebMediaPlayerClientImpl.h" +#include "WebSocket.h" + +using namespace WebCore; + +namespace WebKit { + +void WebRuntimeFeatures::enableDatabase(bool enable) +{ +#if ENABLE(DATABASE) + Database::setIsAvailable(enable); +#endif +} + +bool WebRuntimeFeatures::isDatabaseEnabled() +{ +#if ENABLE(DATABASE) + return Database::isAvailable(); +#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::setWebkitNotificationsEnabled(enable); +#endif +} + +bool WebRuntimeFeatures::isNotificationsEnabled() +{ +#if ENABLE(NOTIFICATIONS) + return RuntimeEnabledFeatures::webkitNotificationsEnabled(); +#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 +} + +void WebRuntimeFeatures::enableGeolocation(bool enable) +{ +#if ENABLE(GEOLOCATION) + RuntimeEnabledFeatures::setGeolocationEnabled(enable); +#endif +} + +bool WebRuntimeFeatures::isGeolocationEnabled() +{ +#if ENABLE(GEOLOCATION) + return RuntimeEnabledFeatures::geolocationEnabled(); +#else + return false; +#endif +} + +void WebRuntimeFeatures::enableIndexedDatabase(bool enable) +{ +#if ENABLE(INDEXED_DATABASE) + RuntimeEnabledFeatures::setIndexedDBEnabled(enable); +#endif +} + +bool WebRuntimeFeatures::isIndexedDatabaseEnabled() +{ +#if ENABLE(INDEXED_DATABASE) + return RuntimeEnabledFeatures::indexedDBEnabled(); +#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..81546da --- /dev/null +++ b/WebKit/chromium/src/WebSecurityOrigin.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 "WebSecurityOrigin.h" + +#include "SecurityOrigin.h" +#include "WebString.h" +#include <wtf/PassRefPtr.h> + +using namespace WebCore; + +namespace WebKit { + +class WebSecurityOriginPrivate : public SecurityOrigin { +}; + +WebSecurityOrigin* WebSecurityOrigin::createFromDatabaseIdentifier(const WebString& databaseIdentifier) +{ + return new WebSecurityOrigin(SecurityOrigin::createFromDatabaseIdentifier(databaseIdentifier)); +} + +WebSecurityOrigin WebSecurityOrigin::createFromString(const WebString& origin) +{ + return WebSecurityOrigin(SecurityOrigin::createFromString(origin)); +} + +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..48b445c --- /dev/null +++ b/WebKit/chromium/src/WebSecurityPolicy.cpp @@ -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. + */ + +#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(); +} + +bool WebSecurityPolicy::shouldHideReferrer(const WebURL& url, const WebString& referrer) +{ + return SecurityOrigin::shouldHideReferrer(url, referrer); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/WebSettingsImpl.cpp b/WebKit/chromium/src/WebSettingsImpl.cpp new file mode 100644 index 0000000..5cfbd4f --- /dev/null +++ b/WebKit/chromium/src/WebSettingsImpl.cpp @@ -0,0 +1,262 @@ +/* + * 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::setImagesEnabled(bool enabled) +{ + m_settings->setImagesEnabled(enabled); +} + +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..3b69fe6 --- /dev/null +++ b/WebKit/chromium/src/WebSettingsImpl.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 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 setImagesEnabled(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..9a7fd5c --- /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, Result& result, WebString& oldValue) +{ + int exceptionCode = 0; + + ScopedStorageEventURL scope(url); + oldValue = m_storageArea->setItem(key, value, exceptionCode, 0); + + if (exceptionCode) { + ASSERT(exceptionCode == WebCore::QUOTA_EXCEEDED_ERR); + result = ResultBlockedByQuota; + } else + result = ResultOK; +} + +void WebStorageAreaImpl::removeItem(const WebString& key, const WebURL& url, WebString& oldValue) +{ + ScopedStorageEventURL scope(url); + oldValue = m_storageArea->removeItem(key, 0); +} + +void WebStorageAreaImpl::clear(const WebURL& url, bool& somethingCleared) +{ + ScopedStorageEventURL scope(url); + somethingCleared = 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..e9a11c2 --- /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, Result& result, WebString& oldValue); + virtual void removeItem(const WebString& key, const WebURL& url, WebString& oldValue); + virtual void clear(const WebURL& url, bool& somethingCleared); + + // 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..36d5f86 --- /dev/null +++ b/WebKit/chromium/src/WebString.cpp @@ -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. + */ + +#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); +} + +bool WebString::equals(const WebString& s) const +{ + return equal(m_private, s.m_private); +} + +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..95e0be2 --- /dev/null +++ b/WebKit/chromium/src/WebURLResponse.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 "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; +} + +bool WebURLResponse::wasFetchedViaSPDY() const +{ + return m_private->m_resourceResponse->wasFetchedViaSPDY(); +} + +void WebURLResponse::setWasFetchedViaSPDY(bool value) +{ + m_private->m_resourceResponse->setWasFetchedViaSPDY(value); +} + +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..ce03523 --- /dev/null +++ b/WebKit/chromium/src/WebViewImpl.cpp @@ -0,0 +1,1919 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebViewImpl.h" + +#include "AutoFillPopupMenuClient.h" +#include "AutocompletePopupMenuClient.h" +#include "AXObjectCache.h" +#include "Chrome.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 "PageGroupLoadDeferrer.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 OS(WINDOWS) +#include "KeyboardCodesWin.h" +#include "RenderThemeChromiumWin.h" +#else +#if OS(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"; + +// Used to defer all page activity in cases where the embedder wishes to run +// a nested event loop. +static PageGroupLoadDeferrer* pageGroupLoadDeferrer; + +// 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 suggestions 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 suggestionsPopupSettings = { + false, // focusOnShow + false, // setTextOnIndexChange + false, // acceptOnAbandon + true, // loopSelectionNavigation + true, // restrictWidthOfListBox. Same as other browser (Fx, IE, and safari) + // For suggestions, 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 WebView::willEnterModalLoop() +{ + // It is not valid to nest more than once. + ASSERT(!pageGroupLoadDeferrer); + + PageGroup* pageGroup = PageGroup::pageGroup(pageGroupName); + ASSERT(pageGroup); + ASSERT(!pageGroup->pages().isEmpty()); + + // Pick any page in the page group since we are deferring all pages. + pageGroupLoadDeferrer = new PageGroupLoadDeferrer(*pageGroup->pages().begin(), true); +} + +void WebView::didExitModalLoop() +{ + // The embedder must have called willEnterNestedEventLoop. + ASSERT(pageGroupLoadDeferrer); + + delete pageGroupLoadDeferrer; + pageGroupLoadDeferrer = 0; +} + +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_suggestionsPopupShowing(false) + , m_suggestionsPopupClient(0) + , m_suggestionsPopup(0) + , 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, + 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 + // suggestions 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 suggestions 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 OS(DARWIN) + if (event.button == WebMouseEvent::ButtonRight + || (event.button == WebMouseEvent::ButtonLeft + && event.modifiers & WebMouseEvent::ControlKey)) + mouseContextMenu(event); +#elif OS(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 OS(WINDOWS) + 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 OS(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(); + FrameView* view = m_page->mainFrame()->view(); + IntPoint clickPoint(m_lastMouseDownPoint.x, m_lastMouseDownPoint.y); + IntPoint contentPoint = view->windowToContents(clickPoint); + HitTestResult hitTestResult = focused->eventHandler()->hitTestResultAtPoint(contentPoint, 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). The main scrollbars + // have to be handled separately. + if (!hitTestResult.scrollbar() && !hitTestResult.isLiveLink() && focused && !view->scrollbarAtPoint(clickPoint)) { + 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 OS(WINDOWS) + // 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 OS(WINDOWS) || OS(LINUX) + const WebInputEvent::Type contextMenuTriggeringEventType = +#if OS(WINDOWS) + WebInputEvent::KeyUp; +#elif OS(LINUX) + WebInputEvent::RawKeyDown; +#endif + + if (((!event.modifiers && (event.windowsKeyCode == VKEY_APPS)) + || ((event.modifiers == WebInputEvent::ShiftKey) && (event.windowsKeyCode == VKEY_F10))) + && event.type == contextMenuTriggeringEventType) { + 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_suggestionsPopupShowing + // 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_suggestionsPopup->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_suggestionsPopup->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->removeSuggestionAtIndex(selectedIndex); + refreshSuggestionsPopup(); + return false; + } + + if (!m_suggestionsPopup->isInterestedInEventForKey(event.windowsKeyCode)) + return false; + + if (m_suggestionsPopup->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 OS(WINDOWS) || OS(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 OS(WINDOWS) + int rightAligned = ::GetSystemMetrics(SM_MENUDROPALIGNMENT); +#else + int rightAligned = 0; +#endif + IntPoint location; + + + Frame* focusedFrame = page()->focusController()->focusedOrMainFrame(); + Node* focusedNode = focusedFrame->document()->focusedNode(); + Position start = mainFrameImpl->selection()->selection().start(); + + if (focusedFrame->editor() && focusedFrame->editor()->canEdit() && start.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) { +#if !OS(DARWIN) + case 'A': + focusedFrame()->executeCommand(WebString::fromUTF8("SelectAll")); + return true; + case VKEY_INSERT: + case 'C': + focusedFrame()->executeCommand(WebString::fromUTF8("Copy")); + return true; +#endif + // 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 { + hideSuggestionsPopup(); + + // 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->mainFrame(); + 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(mediaElement->processingUserGesture()); + else + mediaElement->pause(mediaElement->processingUserGesture()); + 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) +{ + applyAutocompleteSuggestions(node, suggestions, defaultSuggestionIndex); +} + +void WebViewImpl::applyAutoFillSuggestions( + const WebNode& node, + const WebVector<WebString>& names, + const WebVector<WebString>& labels, + int defaultSuggestionIndex) +{ + ASSERT(names.size() == labels.size()); + ASSERT(defaultSuggestionIndex < static_cast<int>(names.size())); + + if (names.isEmpty()) { + hideSuggestionsPopup(); + return; + } + + RefPtr<Node> focusedNode = focusedWebCoreNode(); + // 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 + // caret is at the end and that the text has not changed. + if (!focusedNode || focusedNode != PassRefPtr<Node>(node)) { + hideSuggestionsPopup(); + return; + } + + HTMLInputElement* inputElem = + static_cast<HTMLInputElement*>(focusedNode.get()); + + // The first time the AutoFill popup is shown we'll create the client and + // the popup. + if (!m_autoFillPopupClient.get()) + m_autoFillPopupClient.set(new AutoFillPopupMenuClient); + + m_autoFillPopupClient->initialize(inputElem, names, labels, + defaultSuggestionIndex); + + if (m_suggestionsPopupClient != m_autoFillPopupClient.get()) { + hideSuggestionsPopup(); + m_suggestionsPopupClient = m_autoFillPopupClient.get(); + } + + if (!m_autoFillPopup.get()) { + m_autoFillPopup = PopupContainer::create(m_suggestionsPopupClient, + suggestionsPopupSettings); + } + + if (m_suggestionsPopup != m_autoFillPopup.get()) + m_suggestionsPopup = m_autoFillPopup.get(); + + if (m_suggestionsPopupShowing) { + m_autoFillPopupClient->setSuggestions(names, labels); + refreshSuggestionsPopup(); + } else { + m_suggestionsPopup->show(focusedNode->getRect(), + focusedNode->ownerDocument()->view(), 0); + m_suggestionsPopupShowing = true; + } +} + +void WebViewImpl::applyAutocompleteSuggestions( + const WebNode& node, + const WebVector<WebString>& suggestions, + int defaultSuggestionIndex) +{ + ASSERT(defaultSuggestionIndex < static_cast<int>(suggestions.size())); + + if (!m_page.get() || suggestions.isEmpty()) { + hideSuggestionsPopup(); + return; + } + + RefPtr<Node> focusedNode = focusedWebCoreNode(); + // If the node for which we queried the Autocomplete suggestions is not the + // focused node, then we have nothing to do. FIXME: also check the + // caret is at the end and that the text has not changed. + if (!focusedNode || focusedNode != PassRefPtr<Node>(node)) { + hideSuggestionsPopup(); + 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); + + m_autocompletePopupClient->initialize(inputElem, suggestions, + defaultSuggestionIndex); + + if (m_suggestionsPopupClient != m_autocompletePopupClient.get()) { + hideSuggestionsPopup(); + m_suggestionsPopupClient = m_autocompletePopupClient.get(); + } + + if (!m_autocompletePopup.get()) { + m_autocompletePopup = PopupContainer::create(m_suggestionsPopupClient, + suggestionsPopupSettings); + } + + if (m_suggestionsPopup != m_autocompletePopup.get()) + m_suggestionsPopup = m_autocompletePopup.get(); + + if (m_suggestionsPopupShowing) { + m_autocompletePopupClient->setSuggestions(suggestions); + refreshSuggestionsPopup(); + } else { + m_suggestionsPopup->show(focusedNode->getRect(), + focusedNode->ownerDocument()->view(), 0); + m_suggestionsPopupShowing = true; + } +} + +void WebViewImpl::hideAutofillPopup() +{ + hideSuggestionsPopup(); +} + +void WebViewImpl::hideSuggestionsPopup() +{ + if (m_suggestionsPopupShowing) { + m_suggestionsPopup->hidePopup(); + m_suggestionsPopupShowing = false; + } +} + +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 OS(LINUX) + RenderThemeChromiumLinux::setScrollbarColors(inactiveColor, + activeColor, + trackColor); +#endif +} + +void WebViewImpl::setSelectionColors(unsigned activeBackgroundColor, + unsigned activeForegroundColor, + unsigned inactiveBackgroundColor, + unsigned inactiveForegroundColor) { +#if OS(LINUX) + RenderThemeChromiumLinux::setSelectionColors(activeBackgroundColor, + activeForegroundColor, + inactiveBackgroundColor, + inactiveForegroundColor); + theme()->platformColorsDidChange(); +#endif +} + +void WebViewImpl::addUserScript(const WebString& sourceCode, bool runAtStart) +{ + PageGroup* pageGroup = PageGroup::pageGroup(pageGroupName); + RefPtr<DOMWrapperWorld> world(DOMWrapperWorld::create()); + pageGroup->addUserScriptToWorld(world.get(), sourceCode, WebURL(), 0, 0, + runAtStart ? InjectAtDocumentStart : InjectAtDocumentEnd); +} + +void WebViewImpl::removeAllUserContent() +{ + PageGroup* pageGroup = PageGroup::pageGroup(pageGroupName); + pageGroup->removeAllUserContent(); +} + +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 OS(WINDOWS) || OS(LINUX) || OS(FREEBSD) + const bool newTabModifier = (button == 1) || ctrl; +#elif OS(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::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::refreshSuggestionsPopup() +{ + ASSERT(m_suggestionsPopupShowing); + + // Hide the popup if it has become empty. + if (!m_autocompletePopupClient->listSize()) { + hideSuggestionsPopup(); + return; + } + + IntRect oldBounds = m_suggestionsPopup->boundsRect(); + m_suggestionsPopup->refresh(); + IntRect newBounds = m_suggestionsPopup->boundsRect(); + // Let's resize the backing window if necessary. + if (oldBounds != newBounds) { + WebPopupMenuImpl* popupMenu = + static_cast<WebPopupMenuImpl*>(m_suggestionsPopup->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..286ac43 --- /dev/null +++ b/WebKit/chromium/src/WebViewImpl.h @@ -0,0 +1,454 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef 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 PopupMenuClient; +class Range; +class RenderTheme; +class Widget; +} + +namespace WebKit { +class AutocompletePopupMenuClient; +class AutoFillPopupMenuClient; +class ContextMenuClientImpl; +class SuggestionsPopupMenuClient; +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 applyAutoFillSuggestions( + const WebNode&, + const WebVector<WebString>& names, + const WebVector<WebString>& labels, + int defaultSuggestionIndex); + virtual void applyAutocompleteSuggestions( + const WebNode&, + const WebVector<WebString>& suggestions, + int defaultSuggestionIndex); + virtual void hideAutofillPopup(); + virtual void hideSuggestionsPopup(); + virtual void setScrollbarColors(unsigned inactiveColor, + unsigned activeColor, + unsigned trackColor); + virtual void setSelectionColors(unsigned activeBackgroundColor, + unsigned activeForegroundColor, + unsigned inactiveBackgroundColor, + unsigned inactiveForegroundColor); + virtual void performCustomContextMenuAction(unsigned action); + virtual void addUserScript(const WebString& sourceCode, + bool runAtStart); + virtual void removeAllUserContent(); + + // 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); + + void suggestionsPopupDidHide() + { + m_suggestionsPopupShowing = false; + } + +#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 suggestions popup. Should be called when the suggestions + // have changed. Note that this should only be called when the suggestions + // popup is showing. + void refreshSuggestionsPopup(); + + // 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; + + // Whether a suggestions popup is currently showing. + bool m_suggestionsPopupShowing; + + // A pointer to the current suggestions popup menu client. This can be + // either an AutoFillPopupMenuClient or an AutocompletePopupMenuClient. We + // do not own this pointer. + SuggestionsPopupMenuClient* m_suggestionsPopupClient; + + // The AutoFill popup client. + OwnPtr<AutoFillPopupMenuClient> m_autoFillPopupClient; + + // The Autocomplete popup client. + OwnPtr<AutocompletePopupMenuClient> m_autocompletePopupClient; + + // A pointer to the current suggestions popup. We do not own this pointer. + WebCore::PopupContainer* m_suggestionsPopup; + + // The AutoFill suggestions popup. + RefPtr<WebCore::PopupContainer> m_autoFillPopup; + + // The AutoComplete suggestions popup. + RefPtr<WebCore::PopupContainer> m_autocompletePopup; + + 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..40019e8 --- /dev/null +++ b/WebKit/chromium/src/WebWorkerBase.cpp @@ -0,0 +1,309 @@ +/* + * 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()); + webFrame->frame()->loader()->load(ResourceRequest(url), 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->toWireString(), 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(); + + thisPtr->stopWorkerThread(); +} + +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..598a078 --- /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->toWireString(), + 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->toWireString(), 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::createFromWire(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..5b5e053 --- /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::createFromWire(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/js/DebuggerAgent.js b/WebKit/chromium/src/js/DebuggerAgent.js new file mode 100644 index 0000000..301620a --- /dev/null +++ b/WebKit/chromium/src/js/DebuggerAgent.js @@ -0,0 +1,1528 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** + * @fileoverview Provides communication interface to remote v8 debugger. See + * protocol decription at http://code.google.com/p/v8/wiki/DebuggerProtocol + */ + +/** + * FIXME: change field naming style to use trailing underscore. + * @constructor + */ +devtools.DebuggerAgent = function() +{ + RemoteDebuggerAgent.debuggerOutput = this.handleDebuggerOutput_.bind(this); + RemoteDebuggerAgent.setContextId = this.setContextId_.bind(this); + + /** + * Id of the inspected page global context. It is used for filtering scripts. + * @type {number} + */ + this.contextId_ = null; + + /** + * Mapping from script id to script info. + * @type {Object} + */ + this.parsedScripts_ = null; + + /** + * Mapping from the request id to the devtools.BreakpointInfo for the + * breakpoints whose v8 ids are not set yet. These breakpoints are waiting for + * "setbreakpoint" responses to learn their ids in the v8 debugger. + * @see #handleSetBreakpointResponse_ + * @type {Object} + */ + this.requestNumberToBreakpointInfo_ = null; + + /** + * Information on current stack frames. + * @type {Array.<devtools.CallFrame>} + */ + this.callFrames_ = []; + + /** + * Whether to stop in the debugger on the exceptions. + * @type {boolean} + */ + this.pauseOnExceptions_ = false; + + /** + * Mapping: request sequence number->callback. + * @type {Object} + */ + this.requestSeqToCallback_ = null; + + /** + * Whether the scripts panel has been shown and initialilzed. + * @type {boolean} + */ + this.scriptsPanelInitialized_ = false; + + /** + * Whether the scripts list should be requested next time when context id is + * set. + * @type {boolean} + */ + this.requestScriptsWhenContextIdSet_ = false; + + /** + * Whether the agent is waiting for initial scripts response. + * @type {boolean} + */ + this.waitingForInitialScriptsResponse_ = false; + + /** + * If backtrace response is received when initial scripts response + * is not yet processed the backtrace handling will be postponed until + * after the scripts response processing. The handler bound to its arguments + * and this agent will be stored in this field then. + * @type {?function()} + */ + this.pendingBacktraceResponseHandler_ = null; + + /** + * Container of all breakpoints set using resource URL. These breakpoints + * survive page reload. Breakpoints set by script id(for scripts that don't + * have URLs) are stored in ScriptInfo objects. + * @type {Object} + */ + this.urlToBreakpoints_ = {}; + + + /** + * Exception message that is shown to user while on exception break. + * @type {WebInspector.ConsoleMessage} + */ + this.currentExceptionMessage_ = null; +}; + + +/** + * A copy of the scope types from v8/src/mirror-delay.js + * @enum {number} + */ +devtools.DebuggerAgent.ScopeType = { + Global: 0, + Local: 1, + With: 2, + Closure: 3, + Catch: 4 +}; + + +/** + * Resets debugger agent to its initial state. + */ +devtools.DebuggerAgent.prototype.reset = function() +{ + this.contextId_ = null; + // No need to request scripts since they all will be pushed in AfterCompile + // events. + this.requestScriptsWhenContextIdSet_ = false; + this.waitingForInitialScriptsResponse_ = false; + + this.parsedScripts_ = {}; + this.requestNumberToBreakpointInfo_ = {}; + this.callFrames_ = []; + this.requestSeqToCallback_ = {}; +}; + + +/** + * Initializes scripts UI. This method is called every time Scripts panel + * is shown. It will send request for context id if it's not set yet. + */ +devtools.DebuggerAgent.prototype.initUI = function() +{ + // Initialize scripts cache when Scripts panel is shown first time. + if (this.scriptsPanelInitialized_) + return; + this.scriptsPanelInitialized_ = true; + if (this.contextId_) { + // We already have context id. This means that we are here from the + // very beginning of the page load cycle and hence will get all scripts + // via after-compile events. No need to request scripts for this session. + // + // There can be a number of scripts from after-compile events that are + // pending addition into the UI. + for (var scriptId in this.parsedScripts_) { + var script = this.parsedScripts_[scriptId]; + WebInspector.parsedScriptSource(scriptId, script.getUrl(), undefined /* script source */, script.getLineOffset()); + } + return; + } + this.waitingForInitialScriptsResponse_ = true; + // Script list should be requested only when current context id is known. + RemoteDebuggerAgent.getContextId(); + this.requestScriptsWhenContextIdSet_ = true; +}; + + +/** + * Asynchronously requests the debugger for the script source. + * @param {number} scriptId Id of the script whose source should be resolved. + * @param {function(source:?string):void} callback Function that will be called + * when the source resolution is completed. "source" parameter will be null + * if the resolution fails. + */ +devtools.DebuggerAgent.prototype.resolveScriptSource = function(scriptId, callback) +{ + var script = this.parsedScripts_[scriptId]; + if (!script || script.isUnresolved()) { + callback(null); + return; + } + + var cmd = new devtools.DebugCommand("scripts", { + "ids": [scriptId], + "includeSource": true + }); + devtools.DebuggerAgent.sendCommand_(cmd); + // Force v8 execution so that it gets to processing the requested command. + RemoteDebuggerAgent.processDebugCommands(); + + this.requestSeqToCallback_[cmd.getSequenceNumber()] = function(msg) { + if (msg.isSuccess()) { + var scriptJson = msg.getBody()[0]; + if (scriptJson) + callback(scriptJson.source); + else + callback(null); + } else + callback(null); + }; +}; + + +/** + * Tells the v8 debugger to stop on as soon as possible. + */ +devtools.DebuggerAgent.prototype.pauseExecution = function() +{ + RemoteDebuggerCommandExecutor.DebuggerPauseScript(); +}; + + +/** + * @param {number} sourceId Id of the script fot the breakpoint. + * @param {number} line Number of the line for the breakpoint. + * @param {?string} condition The breakpoint condition. + */ +devtools.DebuggerAgent.prototype.addBreakpoint = function(sourceId, line, condition) +{ + var script = this.parsedScripts_[sourceId]; + if (!script) + return; + + line = devtools.DebuggerAgent.webkitToV8LineNumber_(line); + + var commandArguments; + if (script.getUrl()) { + var breakpoints = this.urlToBreakpoints_[script.getUrl()]; + if (breakpoints && breakpoints[line]) + return; + if (!breakpoints) { + breakpoints = {}; + this.urlToBreakpoints_[script.getUrl()] = breakpoints; + } + + var breakpointInfo = new devtools.BreakpointInfo(line); + breakpoints[line] = breakpointInfo; + + commandArguments = { + "groupId": this.contextId_, + "type": "script", + "target": script.getUrl(), + "line": line, + "condition": condition + }; + } else { + var breakpointInfo = script.getBreakpointInfo(line); + if (breakpointInfo) + return; + + breakpointInfo = new devtools.BreakpointInfo(line); + script.addBreakpointInfo(breakpointInfo); + + commandArguments = { + "groupId": this.contextId_, + "type": "scriptId", + "target": sourceId, + "line": line, + "condition": condition + }; + } + + var cmd = new devtools.DebugCommand("setbreakpoint", commandArguments); + + this.requestNumberToBreakpointInfo_[cmd.getSequenceNumber()] = breakpointInfo; + + devtools.DebuggerAgent.sendCommand_(cmd); + // Force v8 execution so that it gets to processing the requested command. + // It is necessary for being able to change a breakpoint just after it + // has been created (since we need an existing breakpoint id for that). + RemoteDebuggerAgent.processDebugCommands(); +}; + + +/** + * @param {number} sourceId Id of the script for the breakpoint. + * @param {number} line Number of the line for the breakpoint. + */ +devtools.DebuggerAgent.prototype.removeBreakpoint = function(sourceId, line) +{ + var script = this.parsedScripts_[sourceId]; + if (!script) + return; + + line = devtools.DebuggerAgent.webkitToV8LineNumber_(line); + + var breakpointInfo; + if (script.getUrl()) { + var breakpoints = this.urlToBreakpoints_[script.getUrl()]; + breakpointInfo = breakpoints[line]; + delete breakpoints[line]; + } else { + breakpointInfo = script.getBreakpointInfo(line); + if (breakpointInfo) + script.removeBreakpointInfo(breakpointInfo); + } + + if (!breakpointInfo) + return; + + breakpointInfo.markAsRemoved(); + + var id = breakpointInfo.getV8Id(); + + // If we don't know id of this breakpoint in the v8 debugger we cannot send + // "clearbreakpoint" request. In that case it will be removed in + // "setbreakpoint" response handler when we learn the id. + if (id !== -1) { + this.requestClearBreakpoint_(id); + } +}; + + +/** + * @param {number} sourceId Id of the script for the breakpoint. + * @param {number} line Number of the line for the breakpoint. + * @param {?string} condition New breakpoint condition. + */ +devtools.DebuggerAgent.prototype.updateBreakpoint = function(sourceId, line, condition) +{ + var script = this.parsedScripts_[sourceId]; + if (!script) + return; + + line = devtools.DebuggerAgent.webkitToV8LineNumber_(line); + + var breakpointInfo; + if (script.getUrl()) { + var breakpoints = this.urlToBreakpoints_[script.getUrl()]; + breakpointInfo = breakpoints[line]; + } else + breakpointInfo = script.getBreakpointInfo(line); + + var id = breakpointInfo.getV8Id(); + + // If we don't know id of this breakpoint in the v8 debugger we cannot send + // the "changebreakpoint" request. + if (id !== -1) { + // TODO(apavlov): make use of the real values for "enabled" and + // "ignoreCount" when appropriate. + this.requestChangeBreakpoint_(id, true, condition, null); + } +}; + + +/** + * Tells the v8 debugger to step into the next statement. + */ +devtools.DebuggerAgent.prototype.stepIntoStatement = function() +{ + this.stepCommand_("in"); +}; + + +/** + * Tells the v8 debugger to step out of current function. + */ +devtools.DebuggerAgent.prototype.stepOutOfFunction = function() +{ + this.stepCommand_("out"); +}; + + +/** + * Tells the v8 debugger to step over the next statement. + */ +devtools.DebuggerAgent.prototype.stepOverStatement = function() +{ + this.stepCommand_("next"); +}; + + +/** + * Tells the v8 debugger to continue execution after it has been stopped on a + * breakpoint or an exception. + */ +devtools.DebuggerAgent.prototype.resumeExecution = function() +{ + this.clearExceptionMessage_(); + var cmd = new devtools.DebugCommand("continue"); + devtools.DebuggerAgent.sendCommand_(cmd); +}; + + +/** + * Creates exception message and schedules it for addition to the resource upon + * backtrace availability. + * @param {string} url Resource url. + * @param {number} line Resource line number. + * @param {string} message Exception text. + */ +devtools.DebuggerAgent.prototype.createExceptionMessage_ = function(url, line, message) +{ + this.currentExceptionMessage_ = new WebInspector.ConsoleMessage( + WebInspector.ConsoleMessage.MessageSource.JS, + WebInspector.ConsoleMessage.MessageType.Log, + WebInspector.ConsoleMessage.MessageLevel.Error, + line, + url, + 0 /* group level */, + 1 /* repeat count */, + "[Exception] " + message); +}; + + +/** + * Shows pending exception message that is created with createExceptionMessage_ + * earlier. + */ +devtools.DebuggerAgent.prototype.showPendingExceptionMessage_ = function() +{ + if (!this.currentExceptionMessage_) + return; + var msg = this.currentExceptionMessage_; + var resource = WebInspector.resourceURLMap[msg.url]; + if (resource) { + msg.resource = resource; + WebInspector.panels.resources.addMessageToResource(resource, msg); + } else + this.currentExceptionMessage_ = null; +}; + + +/** + * Clears exception message from the resource. + */ +devtools.DebuggerAgent.prototype.clearExceptionMessage_ = function() +{ + if (this.currentExceptionMessage_) { + var messageElement = this.currentExceptionMessage_._resourceMessageLineElement; + var bubble = messageElement.parentElement; + bubble.removeChild(messageElement); + if (!bubble.firstChild) { + // Last message in bubble removed. + bubble.parentElement.removeChild(bubble); + } + this.currentExceptionMessage_ = null; + } +}; + + +/** + * @return {boolean} True iff the debugger will pause execution on the + * exceptions. + */ +devtools.DebuggerAgent.prototype.pauseOnExceptions = function() +{ + return this.pauseOnExceptions_; +}; + + +/** + * Tells whether to pause in the debugger on the exceptions or not. + * @param {boolean} value True iff execution should be stopped in the debugger + * on the exceptions. + */ +devtools.DebuggerAgent.prototype.setPauseOnExceptions = function(value) +{ + this.pauseOnExceptions_ = value; +}; + + +/** + * Sends "evaluate" request to the debugger. + * @param {Object} arguments Request arguments map. + * @param {function(devtools.DebuggerMessage)} callback Callback to be called + * when response is received. + */ +devtools.DebuggerAgent.prototype.requestEvaluate = function(arguments, callback) +{ + var cmd = new devtools.DebugCommand("evaluate", arguments); + devtools.DebuggerAgent.sendCommand_(cmd); + this.requestSeqToCallback_[cmd.getSequenceNumber()] = callback; +}; + + +/** + * Sends "lookup" request for each unresolved property of the object. When + * response is received the properties will be changed with their resolved + * values. + * @param {Object} object Object whose properties should be resolved. + * @param {function(devtools.DebuggerMessage)} Callback to be called when all + * children are resolved. + * @param {boolean} noIntrinsic Whether intrinsic properties should be included. + */ +devtools.DebuggerAgent.prototype.resolveChildren = function(object, callback, noIntrinsic) +{ + if ("handle" in object) { + var result = []; + devtools.DebuggerAgent.formatObjectProperties_(object, result, noIntrinsic); + callback(result); + } else { + this.requestLookup_([object.ref], function(msg) { + var result = []; + if (msg.isSuccess()) { + var handleToObject = msg.getBody(); + var resolved = handleToObject[object.ref]; + devtools.DebuggerAgent.formatObjectProperties_(resolved, result, noIntrinsic); + callback(result); + } else + callback([]); + }); + } +}; + + +/** + * Sends "scope" request for the scope object to resolve its variables. + * @param {Object} scope Scope to be resolved. + * @param {function(Array.<WebInspector.ObjectPropertyProxy>)} callback + * Callback to be called when all scope variables are resolved. + */ +devtools.DebuggerAgent.prototype.resolveScope = function(scope, callback) +{ + var cmd = new devtools.DebugCommand("scope", { + "frameNumber": scope.frameNumber, + "number": scope.index, + "compactFormat": true + }); + devtools.DebuggerAgent.sendCommand_(cmd); + this.requestSeqToCallback_[cmd.getSequenceNumber()] = function(msg) { + var result = []; + if (msg.isSuccess()) { + var scopeObjectJson = msg.getBody().object; + devtools.DebuggerAgent.formatObjectProperties_(scopeObjectJson, result, true /* no intrinsic */); + } + callback(result); + }; +}; + + +/** + * Sends "scopes" request for the frame object to resolve all variables + * available in the frame. + * @param {number} callFrameId Id of call frame whose variables need to + * be resolved. + * @param {function(Object)} callback Callback to be called when all frame + * variables are resolved. + */ +devtools.DebuggerAgent.prototype.resolveFrameVariables_ = function(callFrameId, callback) +{ + var result = {}; + + var frame = this.callFrames_[callFrameId]; + if (!frame) { + callback(result); + return; + } + + var waitingResponses = 0; + function scopeResponseHandler(msg) { + waitingResponses--; + + if (msg.isSuccess()) { + var properties = msg.getBody().object.properties; + for (var j = 0; j < properties.length; j++) + result[properties[j].name] = true; + } + + // When all scopes are resolved invoke the callback. + if (waitingResponses === 0) + callback(result); + }; + + for (var i = 0; i < frame.scopeChain.length; i++) { + var scope = frame.scopeChain[i].objectId; + if (scope.type === devtools.DebuggerAgent.ScopeType.Global) { + // Do not resolve global scope since it takes for too long. + // TODO(yurys): allow to send only property names in the response. + continue; + } + var cmd = new devtools.DebugCommand("scope", { + "frameNumber": scope.frameNumber, + "number": scope.index, + "compactFormat": true + }); + devtools.DebuggerAgent.sendCommand_(cmd); + this.requestSeqToCallback_[cmd.getSequenceNumber()] = scopeResponseHandler; + waitingResponses++; + } +}; + +/** + * Evaluates the expressionString to an object in the call frame and reports + * all its properties. + * @param{string} expressionString Expression whose properties should be + * collected. + * @param{number} callFrameId The frame id. + * @param{function(Object result,bool isException)} reportCompletions Callback + * function. + */ +devtools.DebuggerAgent.prototype.resolveCompletionsOnFrame = function(expressionString, callFrameId, reportCompletions) +{ + if (expressionString) { + expressionString = "var obj = " + expressionString + + "; var names = {}; for (var n in obj) { names[n] = true; };" + + "names;"; + this.evaluateInCallFrame( + callFrameId, + expressionString, + function(result) { + var names = {}; + if (!result.isException) { + var props = result.value.objectId.properties; + // Put all object properties into the map. + for (var i = 0; i < props.length; i++) + names[props[i].name] = true; + } + reportCompletions(names, result.isException); + }); + } else { + this.resolveFrameVariables_(callFrameId, + function(result) { + reportCompletions(result, false /* isException */); + }); + } +}; + + +/** + * @param{number} scriptId + * @return {string} Type of the context of the script with specified id. + */ +devtools.DebuggerAgent.prototype.getScriptContextType = function(scriptId) +{ + return this.parsedScripts_[scriptId].getContextType(); +}; + + +/** + * Removes specified breakpoint from the v8 debugger. + * @param {number} breakpointId Id of the breakpoint in the v8 debugger. + */ +devtools.DebuggerAgent.prototype.requestClearBreakpoint_ = function(breakpointId) +{ + var cmd = new devtools.DebugCommand("clearbreakpoint", { + "breakpoint": breakpointId + }); + devtools.DebuggerAgent.sendCommand_(cmd); +}; + + +/** + * Changes breakpoint parameters in the v8 debugger. + * @param {number} breakpointId Id of the breakpoint in the v8 debugger. + * @param {boolean} enabled Whether to enable the breakpoint. + * @param {?string} condition New breakpoint condition. + * @param {number} ignoreCount New ignore count for the breakpoint. + */ +devtools.DebuggerAgent.prototype.requestChangeBreakpoint_ = function(breakpointId, enabled, condition, ignoreCount) +{ + var cmd = new devtools.DebugCommand("changebreakpoint", { + "breakpoint": breakpointId, + "enabled": enabled, + "condition": condition, + "ignoreCount": ignoreCount + }); + devtools.DebuggerAgent.sendCommand_(cmd); +}; + + +/** + * Sends "backtrace" request to v8. + */ +devtools.DebuggerAgent.prototype.requestBacktrace_ = function() +{ + var cmd = new devtools.DebugCommand("backtrace", { + "compactFormat":true + }); + devtools.DebuggerAgent.sendCommand_(cmd); +}; + + +/** + * Sends command to v8 debugger. + * @param {devtools.DebugCommand} cmd Command to execute. + */ +devtools.DebuggerAgent.sendCommand_ = function(cmd) +{ + RemoteDebuggerCommandExecutor.DebuggerCommand(cmd.toJSONProtocol()); +}; + + +/** + * Tells the v8 debugger to make the next execution step. + * @param {string} action "in", "out" or "next" action. + */ +devtools.DebuggerAgent.prototype.stepCommand_ = function(action) +{ + this.clearExceptionMessage_(); + var cmd = new devtools.DebugCommand("continue", { + "stepaction": action, + "stepcount": 1 + }); + devtools.DebuggerAgent.sendCommand_(cmd); +}; + + +/** + * Sends "lookup" request to v8. + * @param {number} handle Handle to the object to lookup. + */ +devtools.DebuggerAgent.prototype.requestLookup_ = function(handles, callback) +{ + var cmd = new devtools.DebugCommand("lookup", { + "compactFormat":true, + "handles": handles + }); + devtools.DebuggerAgent.sendCommand_(cmd); + this.requestSeqToCallback_[cmd.getSequenceNumber()] = callback; +}; + + +/** + * Sets debugger context id for scripts filtering. + * @param {number} contextId Id of the inspected page global context. + */ +devtools.DebuggerAgent.prototype.setContextId_ = function(contextId) +{ + this.contextId_ = contextId; + + // If it's the first time context id is set request scripts list. + if (this.requestScriptsWhenContextIdSet_) { + this.requestScriptsWhenContextIdSet_ = false; + var cmd = new devtools.DebugCommand("scripts", { + "includeSource": false + }); + devtools.DebuggerAgent.sendCommand_(cmd); + // Force v8 execution so that it gets to processing the requested command. + RemoteDebuggerAgent.processDebugCommands(); + + var debuggerAgent = this; + this.requestSeqToCallback_[cmd.getSequenceNumber()] = function(msg) { + // Handle the response iff the context id hasn't changed since the request + // was issued. Otherwise if the context id did change all up-to-date + // scripts will be pushed in after compile events and there is no need to + // handle the response. + if (contextId === debuggerAgent.contextId_) + debuggerAgent.handleScriptsResponse_(msg); + + // We received initial scripts response so flush the flag and + // see if there is an unhandled backtrace response. + debuggerAgent.waitingForInitialScriptsResponse_ = false; + if (debuggerAgent.pendingBacktraceResponseHandler_) { + debuggerAgent.pendingBacktraceResponseHandler_(); + debuggerAgent.pendingBacktraceResponseHandler_ = null; + } + }; + } +}; + + +/** + * Handles output sent by v8 debugger. The output is either asynchronous event + * or response to a previously sent request. See protocol definitioun for more + * details on the output format. + * @param {string} output + */ +devtools.DebuggerAgent.prototype.handleDebuggerOutput_ = function(output) +{ + var msg; + try { + msg = new devtools.DebuggerMessage(output); + } catch(e) { + debugPrint("Failed to handle debugger response:\n" + e); + throw e; + } + + if (msg.getType() === "event") { + if (msg.getEvent() === "break") + this.handleBreakEvent_(msg); + else if (msg.getEvent() === "exception") + this.handleExceptionEvent_(msg); + else if (msg.getEvent() === "afterCompile") + this.handleAfterCompileEvent_(msg); + } else if (msg.getType() === "response") { + if (msg.getCommand() === "scripts") + this.invokeCallbackForResponse_(msg); + else if (msg.getCommand() === "setbreakpoint") + this.handleSetBreakpointResponse_(msg); + else if (msg.getCommand() === "clearbreakpoint") + this.handleClearBreakpointResponse_(msg); + else if (msg.getCommand() === "backtrace") + this.handleBacktraceResponse_(msg); + else if (msg.getCommand() === "lookup") + this.invokeCallbackForResponse_(msg); + else if (msg.getCommand() === "evaluate") + this.invokeCallbackForResponse_(msg); + else if (msg.getCommand() === "scope") + this.invokeCallbackForResponse_(msg); + } +}; + + +/** + * @param {devtools.DebuggerMessage} msg + */ +devtools.DebuggerAgent.prototype.handleBreakEvent_ = function(msg) +{ + // Force scrips panel to be shown first. + WebInspector.currentPanel = WebInspector.panels.scripts; + + var body = msg.getBody(); + + var line = devtools.DebuggerAgent.v8ToWwebkitLineNumber_(body.sourceLine); + this.requestBacktrace_(); +}; + + +/** + * @param {devtools.DebuggerMessage} msg + */ +devtools.DebuggerAgent.prototype.handleExceptionEvent_ = function(msg) +{ + // Force scrips panel to be shown first. + WebInspector.currentPanel = WebInspector.panels.scripts; + + var body = msg.getBody(); + // No script field in the body means that v8 failed to parse the script. We + // resume execution on parser errors automatically. + if (this.pauseOnExceptions_ && body.script) { + var line = devtools.DebuggerAgent.v8ToWwebkitLineNumber_(body.sourceLine); + this.createExceptionMessage_(body.script.name, line, body.exception.text); + this.requestBacktrace_(); + } else + this.resumeExecution(); +}; + + +/** + * @param {devtools.DebuggerMessage} msg + */ +devtools.DebuggerAgent.prototype.handleScriptsResponse_ = function(msg) +{ + var scripts = msg.getBody(); + for (var i = 0; i < scripts.length; i++) { + var script = scripts[i]; + + // Skip scripts from other tabs. + if (!this.isScriptFromInspectedContext_(script, msg)) + continue; + + // We may already have received the info in an afterCompile event. + if (script.id in this.parsedScripts_) + continue; + this.addScriptInfo_(script, msg); + } +}; + + +/** + * @param {Object} script Json object representing script. + * @param {devtools.DebuggerMessage} msg Debugger response. + */ +devtools.DebuggerAgent.prototype.isScriptFromInspectedContext_ = function(script, msg) +{ + if (!script.context) { + // Always ignore scripts from the utility context. + return false; + } + var context = msg.lookup(script.context.ref); + var scriptContextId = context.data; + if (typeof scriptContextId === "undefined") + return false; // Always ignore scripts from the utility context. + if (this.contextId_ === null) + return true; + // Find the id from context data. The context data has the format "type,id". + var comma = context.data.indexOf(","); + if (comma < 0) + return false; + return (context.data.substring(comma + 1) == this.contextId_); +}; + + +/** + * @param {devtools.DebuggerMessage} msg + */ +devtools.DebuggerAgent.prototype.handleSetBreakpointResponse_ = function(msg) +{ + var requestSeq = msg.getRequestSeq(); + var breakpointInfo = this.requestNumberToBreakpointInfo_[requestSeq]; + if (!breakpointInfo) { + // TODO(yurys): handle this case + return; + } + delete this.requestNumberToBreakpointInfo_[requestSeq]; + if (!msg.isSuccess()) { + // TODO(yurys): handle this case + return; + } + var idInV8 = msg.getBody().breakpoint; + breakpointInfo.setV8Id(idInV8); + + if (breakpointInfo.isRemoved()) + this.requestClearBreakpoint_(idInV8); +}; + + +/** + * @param {devtools.DebuggerMessage} msg + */ +devtools.DebuggerAgent.prototype.handleAfterCompileEvent_ = function(msg) +{ + if (!this.contextId_) { + // Ignore scripts delta if main request has not been issued yet. + return; + } + var script = msg.getBody().script; + + // Ignore scripts from other tabs. + if (!this.isScriptFromInspectedContext_(script, msg)) + return; + this.addScriptInfo_(script, msg); +}; + + +/** + * Adds the script info to the local cache. This method assumes that the script + * is not in the cache yet. + * @param {Object} script Script json object from the debugger message. + * @param {devtools.DebuggerMessage} msg Debugger message containing the script + * data. + */ +devtools.DebuggerAgent.prototype.addScriptInfo_ = function(script, msg) +{ + var context = msg.lookup(script.context.ref); + var contextType; + // Find the type from context data. The context data has the format + // "type,id". + var comma = context.data.indexOf(","); + if (comma < 0) + return + contextType = context.data.substring(0, comma); + this.parsedScripts_[script.id] = new devtools.ScriptInfo(script.id, script.name, script.lineOffset, contextType); + if (this.scriptsPanelInitialized_) { + // Only report script as parsed after scripts panel has been shown. + WebInspector.parsedScriptSource(script.id, script.name, script.source, script.lineOffset); + } +}; + + +/** + * @param {devtools.DebuggerMessage} msg + */ +devtools.DebuggerAgent.prototype.handleClearBreakpointResponse_ = function(msg) +{ + // Do nothing. +}; + + +/** + * Handles response to "backtrace" command. + * @param {devtools.DebuggerMessage} msg + */ +devtools.DebuggerAgent.prototype.handleBacktraceResponse_ = function(msg) +{ + if (this.waitingForInitialScriptsResponse_) + this.pendingBacktraceResponseHandler_ = this.doHandleBacktraceResponse_.bind(this, msg); + else + this.doHandleBacktraceResponse_(msg); +}; + + +/** + * @param {devtools.DebuggerMessage} msg + */ +devtools.DebuggerAgent.prototype.doHandleBacktraceResponse_ = function(msg) +{ + var frames = msg.getBody().frames; + this.callFrames_ = []; + for (var i = 0; i < frames.length; ++i) + this.callFrames_.push(this.formatCallFrame_(frames[i])); + WebInspector.pausedScript(this.callFrames_); + this.showPendingExceptionMessage_(); + InspectorFrontendHost.activateWindow(); +}; + + +/** + * Evaluates code on given callframe. + */ +devtools.DebuggerAgent.prototype.evaluateInCallFrame = function(callFrameId, code, callback) +{ + var callFrame = this.callFrames_[callFrameId]; + callFrame.evaluate_(code, callback); +}; + + +/** + * Handles response to a command by invoking its callback (if any). + * @param {devtools.DebuggerMessage} msg + * @return {boolean} Whether a callback for the given message was found and + * excuted. + */ +devtools.DebuggerAgent.prototype.invokeCallbackForResponse_ = function(msg) +{ + var callback = this.requestSeqToCallback_[msg.getRequestSeq()]; + if (!callback) { + // It may happend if reset was called. + return false; + } + delete this.requestSeqToCallback_[msg.getRequestSeq()]; + callback(msg); + return true; +}; + + +/** + * @param {Object} stackFrame Frame json object from "backtrace" response. + * @return {!devtools.CallFrame} Object containing information related to the + * call frame in the format expected by ScriptsPanel and its panes. + */ +devtools.DebuggerAgent.prototype.formatCallFrame_ = function(stackFrame) +{ + var func = stackFrame.func; + var sourceId = func.scriptId; + + // Add service script if it does not exist. + var existingScript = this.parsedScripts_[sourceId]; + if (!existingScript) { + this.parsedScripts_[sourceId] = new devtools.ScriptInfo(sourceId, null /* name */, 0 /* line */, "unknown" /* type */, true /* unresolved */); + WebInspector.parsedScriptSource(sourceId, null, null, 0); + } + + var funcName = func.name || func.inferredName || "(anonymous function)"; + var line = devtools.DebuggerAgent.v8ToWwebkitLineNumber_(stackFrame.line); + + // Add basic scope chain info with scope variables. + var scopeChain = []; + var ScopeType = devtools.DebuggerAgent.ScopeType; + for (var i = 0; i < stackFrame.scopes.length; i++) { + var scope = stackFrame.scopes[i]; + scope.frameNumber = stackFrame.index; + var scopeObjectProxy = new WebInspector.ObjectProxy(0, scope, [], 0, "", true); + scopeObjectProxy.isScope = true; + switch(scope.type) { + case ScopeType.Global: + scopeObjectProxy.isDocument = true; + break; + case ScopeType.Local: + scopeObjectProxy.isLocal = true; + scopeObjectProxy.thisObject = devtools.DebuggerAgent.formatObjectProxy_(stackFrame.receiver); + break; + case ScopeType.With: + // Catch scope is treated as a regular with scope by WebKit so we + // also treat it this way. + case ScopeType.Catch: + scopeObjectProxy.isWithBlock = true; + break; + case ScopeType.Closure: + scopeObjectProxy.isClosure = true; + break; + } + scopeChain.push(scopeObjectProxy); + } + return new devtools.CallFrame(stackFrame.index, "function", funcName, sourceId, line, scopeChain); +}; + + +/** + * Collects properties for an object from the debugger response. + * @param {Object} object An object from the debugger protocol response. + * @param {Array.<WebInspector.ObjectPropertyProxy>} result An array to put the + * properties into. + * @param {boolean} noIntrinsic Whether intrinsic properties should be + * included. + */ +devtools.DebuggerAgent.formatObjectProperties_ = function(object, result, noIntrinsic) +{ + devtools.DebuggerAgent.propertiesToProxies_(object.properties, result); + if (noIntrinsic) + return; + + result.push(new WebInspector.ObjectPropertyProxy("__proto__", devtools.DebuggerAgent.formatObjectProxy_(object.protoObject))); + result.push(new WebInspector.ObjectPropertyProxy("constructor", devtools.DebuggerAgent.formatObjectProxy_(object.constructorFunction))); + // Don't add 'prototype' property since it is one of the regualar properties. +}; + + +/** + * For each property in "properties" creates its proxy representative. + * @param {Array.<Object>} properties Receiver properties or locals array from + * "backtrace" response. + * @param {Array.<WebInspector.ObjectPropertyProxy>} Results holder. + */ +devtools.DebuggerAgent.propertiesToProxies_ = function(properties, result) +{ + var map = {}; + for (var i = 0; i < properties.length; ++i) { + var property = properties[i]; + var name = String(property.name); + if (name in map) + continue; + map[name] = true; + var value = devtools.DebuggerAgent.formatObjectProxy_(property.value); + var propertyProxy = new WebInspector.ObjectPropertyProxy(name, value); + result.push(propertyProxy); + } +}; + + +/** + * @param {Object} v An object reference from the debugger response. + * @return {*} The value representation expected by ScriptsPanel. + */ +devtools.DebuggerAgent.formatObjectProxy_ = function(v) +{ + var description; + var hasChildren = false; + if (v.type === "object") { + description = v.className; + hasChildren = true; + } else if (v.type === "function") { + if (v.source) + description = v.source; + else + description = "function " + v.name + "()"; + hasChildren = true; + } else if (v.type === "undefined") + description = "undefined"; + else if (v.type === "null") + description = "null"; + else if (typeof v.value !== "undefined") { + // Check for undefined and null types before checking the value, otherwise + // null/undefined may have blank value. + description = v.value; + } else + description = "<unresolved ref: " + v.ref + ", type: " + v.type + ">"; + + var proxy = new WebInspector.ObjectProxy(0, v, [], 0, description, hasChildren); + proxy.type = v.type; + proxy.isV8Ref = true; + return proxy; +}; + + +/** + * Converts line number from Web Inspector UI(1-based) to v8(0-based). + * @param {number} line Resource line number in Web Inspector UI. + * @return {number} The line number in v8. + */ +devtools.DebuggerAgent.webkitToV8LineNumber_ = function(line) +{ + return line - 1; +}; + + +/** + * Converts line number from v8(0-based) to Web Inspector UI(1-based). + * @param {number} line Resource line number in v8. + * @return {number} The line number in Web Inspector. + */ +devtools.DebuggerAgent.v8ToWwebkitLineNumber_ = function(line) +{ + return line + 1; +}; + + +/** + * @param {number} scriptId Id of the script. + * @param {?string} url Script resource URL if any. + * @param {number} lineOffset First line 0-based offset in the containing + * document. + * @param {string} contextType Type of the script's context: + * "page" - regular script from html page + * "injected" - extension content script + * @param {bool} opt_isUnresolved If true, script will not be resolved. + * @constructor + */ +devtools.ScriptInfo = function(scriptId, url, lineOffset, contextType, opt_isUnresolved) +{ + this.scriptId_ = scriptId; + this.lineOffset_ = lineOffset; + this.contextType_ = contextType; + this.url_ = url; + this.isUnresolved_ = opt_isUnresolved; + + this.lineToBreakpointInfo_ = {}; +}; + + +/** + * @return {number} + */ +devtools.ScriptInfo.prototype.getLineOffset = function() +{ + return this.lineOffset_; +}; + + +/** + * @return {string} + */ +devtools.ScriptInfo.prototype.getContextType = function() +{ + return this.contextType_; +}; + + +/** + * @return {?string} + */ +devtools.ScriptInfo.prototype.getUrl = function() +{ + return this.url_; +}; + + +/** + * @return {?bool} + */ +devtools.ScriptInfo.prototype.isUnresolved = function() +{ + return this.isUnresolved_; +}; + + +/** + * @param {number} line 0-based line number in the script. + * @return {?devtools.BreakpointInfo} Information on a breakpoint at the + * specified line in the script or undefined if there is no breakpoint at + * that line. + */ +devtools.ScriptInfo.prototype.getBreakpointInfo = function(line) +{ + return this.lineToBreakpointInfo_[line]; +}; + + +/** + * Adds breakpoint info to the script. + * @param {devtools.BreakpointInfo} breakpoint + */ +devtools.ScriptInfo.prototype.addBreakpointInfo = function(breakpoint) +{ + this.lineToBreakpointInfo_[breakpoint.getLine()] = breakpoint; +}; + + +/** + * @param {devtools.BreakpointInfo} breakpoint Breakpoint info to be removed. + */ +devtools.ScriptInfo.prototype.removeBreakpointInfo = function(breakpoint) +{ + var line = breakpoint.getLine(); + delete this.lineToBreakpointInfo_[line]; +}; + + + +/** + * @param {number} line Breakpoint 0-based line number in the containing script. + * @constructor + */ +devtools.BreakpointInfo = function(line) +{ + this.line_ = line; + this.v8id_ = -1; + this.removed_ = false; +}; + + +/** + * @return {number} + */ +devtools.BreakpointInfo.prototype.getLine = function(n) +{ + return this.line_; +}; + + +/** + * @return {number} Unique identifier of this breakpoint in the v8 debugger. + */ +devtools.BreakpointInfo.prototype.getV8Id = function(n) +{ + return this.v8id_; +}; + + +/** + * Sets id of this breakpoint in the v8 debugger. + * @param {number} id + */ +devtools.BreakpointInfo.prototype.setV8Id = function(id) +{ + this.v8id_ = id; +}; + + +/** + * Marks this breakpoint as removed from the front-end. + */ +devtools.BreakpointInfo.prototype.markAsRemoved = function() +{ + this.removed_ = true; +}; + + +/** + * @return {boolean} Whether this breakpoint has been removed from the + * front-end. + */ +devtools.BreakpointInfo.prototype.isRemoved = function() +{ + return this.removed_; +}; + + +/** + * Call stack frame data. + * @param {string} id CallFrame id. + * @param {string} type CallFrame type. + * @param {string} functionName CallFrame type. + * @param {string} sourceID Source id. + * @param {number} line Source line. + * @param {Array.<Object>} scopeChain Array of scoped objects. + * @construnctor + */ +devtools.CallFrame = function(id, type, functionName, sourceID, line, scopeChain) +{ + this.id = id; + this.type = type; + this.functionName = functionName; + this.sourceID = sourceID; + this.line = line; + this.scopeChain = scopeChain; +}; + + +/** + * This method issues asynchronous evaluate request, reports result to the + * callback. + * @param {string} expression An expression to be evaluated in the context of + * this call frame. + * @param {function(Object):undefined} callback Callback to report result to. + */ +devtools.CallFrame.prototype.evaluate_ = function(expression, callback) +{ + devtools.tools.getDebuggerAgent().requestEvaluate({ + "expression": expression, + "frame": this.id, + "global": false, + "disable_break": false, + "compactFormat": true + }, + function(response) { + var result = {}; + if (response.isSuccess()) + result.value = devtools.DebuggerAgent.formatObjectProxy_(response.getBody()); + else { + result.value = response.getMessage(); + result.isException = true; + } + callback(result); + }); +}; + + +/** + * JSON based commands sent to v8 debugger. + * @param {string} command Name of the command to execute. + * @param {Object} opt_arguments Command-specific arguments map. + * @constructor + */ +devtools.DebugCommand = function(command, opt_arguments) +{ + this.command_ = command; + this.type_ = "request"; + this.seq_ = ++devtools.DebugCommand.nextSeq_; + if (opt_arguments) + this.arguments_ = opt_arguments; +}; + + +/** + * Next unique number to be used as debugger request sequence number. + * @type {number} + */ +devtools.DebugCommand.nextSeq_ = 1; + + +/** + * @return {number} + */ +devtools.DebugCommand.prototype.getSequenceNumber = function() +{ + return this.seq_; +}; + + +/** + * @return {string} + */ +devtools.DebugCommand.prototype.toJSONProtocol = function() +{ + var json = { + "seq": this.seq_, + "type": this.type_, + "command": this.command_ + } + if (this.arguments_) + json.arguments = this.arguments_; + return JSON.stringify(json); +}; + + +/** + * JSON messages sent from v8 debugger. See protocol definition for more + * details: http://code.google.com/p/v8/wiki/DebuggerProtocol + * @param {string} msg Raw protocol packet as JSON string. + * @constructor + */ +devtools.DebuggerMessage = function(msg) +{ + this.packet_ = JSON.parse(msg); + this.refs_ = []; + if (this.packet_.refs) { + for (var i = 0; i < this.packet_.refs.length; i++) + this.refs_[this.packet_.refs[i].handle] = this.packet_.refs[i]; + } +}; + + +/** + * @return {string} The packet type. + */ +devtools.DebuggerMessage.prototype.getType = function() +{ + return this.packet_.type; +}; + + +/** + * @return {?string} The packet event if the message is an event. + */ +devtools.DebuggerMessage.prototype.getEvent = function() +{ + return this.packet_.event; +}; + + +/** + * @return {?string} The packet command if the message is a response to a + * command. + */ +devtools.DebuggerMessage.prototype.getCommand = function() +{ + return this.packet_.command; +}; + + +/** + * @return {number} The packet request sequence. + */ +devtools.DebuggerMessage.prototype.getRequestSeq = function() +{ + return this.packet_.request_seq; +}; + + +/** + * @return {number} Whether the v8 is running after processing the request. + */ +devtools.DebuggerMessage.prototype.isRunning = function() +{ + return this.packet_.running ? true : false; +}; + + +/** + * @return {boolean} Whether the request succeeded. + */ +devtools.DebuggerMessage.prototype.isSuccess = function() +{ + return this.packet_.success ? true : false; +}; + + +/** + * @return {string} + */ +devtools.DebuggerMessage.prototype.getMessage = function() +{ + return this.packet_.message; +}; + + +/** + * @return {Object} Parsed message body json. + */ +devtools.DebuggerMessage.prototype.getBody = function() +{ + return this.packet_.body; +}; + + +/** + * @param {number} handle Object handle. + * @return {?Object} Returns the object with the handle if it was sent in this + * message(some objects referenced by handles may be missing in the message). + */ +devtools.DebuggerMessage.prototype.lookup = function(handle) +{ + return this.refs_[handle]; +}; diff --git a/WebKit/chromium/src/js/DevTools.js b/WebKit/chromium/src/js/DevTools.js new file mode 100644 index 0000000..dcb181b --- /dev/null +++ b/WebKit/chromium/src/js/DevTools.js @@ -0,0 +1,504 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** + * FIXME: change field naming style to use trailing underscore. + * @fileoverview Tools is a main class that wires all components of the + * DevTools frontend together. It is also responsible for overriding existing + * WebInspector functionality while it is getting upstreamed into WebCore. + */ + +/** + * Dispatches raw message from the host. + * @param {string} remoteName + * @prama {string} methodName + * @param {string} param1, param2, param3 Arguments to dispatch. + */ +devtools$$dispatch = function(remoteName, methodName, param1, param2, param3) +{ + remoteName = "Remote" + remoteName.substring(0, remoteName.length - 8); + var agent = window[remoteName]; + if (!agent) { + debugPrint("No remote agent '" + remoteName + "' found."); + return; + } + var method = agent[methodName]; + if (!method) { + debugPrint("No method '" + remoteName + "." + methodName + "' found."); + return; + } + method.call(this, param1, param2, param3); +}; + + +devtools.ToolsAgent = function() +{ + RemoteToolsAgent.didDispatchOn = WebInspector.Callback.processCallback; + RemoteToolsAgent.frameNavigate = this.frameNavigate_.bind(this); + RemoteToolsAgent.dispatchOnClient = this.dispatchOnClient_.bind(this); + this.debuggerAgent_ = new devtools.DebuggerAgent(); + this.profilerAgent_ = new devtools.ProfilerAgent(); +}; + + +/** + * Resets tools agent to its initial state. + */ +devtools.ToolsAgent.prototype.reset = function() +{ + this.debuggerAgent_.reset(); +}; + + +/** + * @param {string} script Script exression to be evaluated in the context of the + * inspected page. + * @param {function(Object|string, boolean):undefined} opt_callback Function to + * call with the result. + */ +devtools.ToolsAgent.prototype.evaluateJavaScript = function(script, opt_callback) +{ + InspectorBackend.evaluate(script, opt_callback || function() {}); +}; + + +/** + * @return {devtools.DebuggerAgent} Debugger agent instance. + */ +devtools.ToolsAgent.prototype.getDebuggerAgent = function() +{ + return this.debuggerAgent_; +}; + + +/** + * @return {devtools.ProfilerAgent} Profiler agent instance. + */ +devtools.ToolsAgent.prototype.getProfilerAgent = function() +{ + return this.profilerAgent_; +}; + + +/** + * @param {string} url Url frame navigated to. + * @see tools_agent.h + * @private + */ +devtools.ToolsAgent.prototype.frameNavigate_ = function(url) +{ + this.reset(); + // Do not reset Profiles panel. + var profiles = null; + if ("profiles" in WebInspector.panels) { + profiles = WebInspector.panels["profiles"]; + delete WebInspector.panels["profiles"]; + } + WebInspector.reset(); + if (profiles !== null) + WebInspector.panels["profiles"] = profiles; +}; + + +/** + * @param {string} message Serialized call to be dispatched on WebInspector. + * @private + */ +devtools.ToolsAgent.prototype.dispatchOnClient_ = function(message) +{ + var args = JSON.parse(message); + var methodName = args[0]; + var parameters = args.slice(1); + WebInspector[methodName].apply(WebInspector, parameters); +}; + + +/** + * Evaluates js expression. + * @param {string} expr + */ +devtools.ToolsAgent.prototype.evaluate = function(expr) +{ + RemoteToolsAgent.evaluate(expr); +}; + + +/** + * Enables / disables resources panel in the ui. + * @param {boolean} enabled New panel status. + */ +WebInspector.setResourcesPanelEnabled = function(enabled) +{ + InspectorBackend._resourceTrackingEnabled = enabled; + WebInspector.panels.resources.reset(); +}; + + +/** + * Prints string to the inspector console or shows alert if the console doesn't + * exist. + * @param {string} text + */ +function debugPrint(text) { + var console = WebInspector.console; + if (console) { + console.addMessage(new WebInspector.ConsoleMessage( + WebInspector.ConsoleMessage.MessageSource.JS, + WebInspector.ConsoleMessage.MessageType.Log, + WebInspector.ConsoleMessage.MessageLevel.Log, + 1, "chrome://devtools/<internal>", undefined, -1, text)); + } else + alert(text); +} + + +/** + * Global instance of the tools agent. + * @type {devtools.ToolsAgent} + */ +devtools.tools = null; + + +var context = {}; // Used by WebCore's inspector routines. + +/////////////////////////////////////////////////////////////////////////////// +// Here and below are overrides to existing WebInspector methods only. +// TODO(pfeldman): Patch WebCore and upstream changes. +var oldLoaded = WebInspector.loaded; +WebInspector.loaded = function() +{ + devtools.tools = new devtools.ToolsAgent(); + devtools.tools.reset(); + + Preferences.ignoreWhitespace = false; + Preferences.samplingCPUProfiler = true; + Preferences.heapProfilerPresent = true; + oldLoaded.call(this); + + InspectorFrontendHost.loaded(); +}; + + +(function() +{ + + /** + * Handles an F3 keydown event to focus the Inspector search box. + * @param {KeyboardEvent} event Event to optionally handle + * @return {boolean} whether the event has been handled + */ + function handleF3Keydown(event) { + if (event.keyIdentifier === "F3" && !event.altKey && !event.ctrlKey && !event.shiftKey && !event.metaKey) { + var searchField = document.getElementById("search"); + searchField.focus(); + searchField.select(); + event.preventDefault(); + return true; + } + return false; + } + + + var oldKeyDown = WebInspector.documentKeyDown; + /** + * This override allows to intercept keydown events we want to handle in a + * custom way. Some nested documents (iframes) delegate keydown handling to + * WebInspector.documentKeyDown (e.g. SourceFrame). + * @param {KeyboardEvent} event + * @override + */ + WebInspector.documentKeyDown = function(event) { + var isHandled = handleF3Keydown(event); + if (!isHandled) { + // Mute refresh action. + if (event.keyIdentifier === "F5") + event.preventDefault(); + else if (event.keyIdentifier === "U+0052" /* "R" */ && (event.ctrlKey || event.metaKey)) + event.preventDefault(); + else + oldKeyDown.call(this, event); + } + }; +})(); + + +/** + * This override is necessary for adding script source asynchronously. + * @override + */ +WebInspector.ScriptView.prototype.setupSourceFrameIfNeeded = function() +{ + if (!this._frameNeedsSetup) + return; + + this.attach(); + + if (this.script.source) + this.didResolveScriptSource_(); + else { + var self = this; + devtools.tools.getDebuggerAgent().resolveScriptSource( + this.script.sourceID, + function(source) { + self.script.source = source || WebInspector.UIString("<source is not available>"); + self.didResolveScriptSource_(); + }); + } +}; + + +/** + * Performs source frame setup when script source is aready resolved. + */ +WebInspector.ScriptView.prototype.didResolveScriptSource_ = function() +{ + this.sourceFrame.setContent("text/javascript", this.script.source); + this._sourceFrameSetup = true; + delete this._frameNeedsSetup; +}; + + +/** + * @param {string} type Type of the the property value("object" or "function"). + * @param {string} className Class name of the property value. + * @constructor + */ +WebInspector.UnresolvedPropertyValue = function(type, className) +{ + this.type = type; + this.className = className; +}; + + +(function() +{ + var oldShow = WebInspector.ScriptsPanel.prototype.show; + WebInspector.ScriptsPanel.prototype.show = function() + { + devtools.tools.getDebuggerAgent().initUI(); + this.enableToggleButton.visible = false; + oldShow.call(this); + }; +})(); + + +(function InterceptProfilesPanelEvents() +{ + var oldShow = WebInspector.ProfilesPanel.prototype.show; + WebInspector.ProfilesPanel.prototype.show = function() + { + devtools.tools.getProfilerAgent().initializeProfiling(); + this.enableToggleButton.visible = false; + oldShow.call(this); + // Show is called on every show event of a panel, so + // we only need to intercept it once. + WebInspector.ProfilesPanel.prototype.show = oldShow; + }; +})(); + + +/* + * @override + * TODO(mnaganov): Restore l10n when it will be agreed that it is needed. + */ +WebInspector.UIString = function(string) +{ + return String.vsprintf(string, Array.prototype.slice.call(arguments, 1)); +}; + + +// There is no clear way of setting frame title yet. So sniffing main resource +// load. +(function OverrideUpdateResource() { + var originalUpdateResource = WebInspector.updateResource; + WebInspector.updateResource = function(identifier, payload) + { + originalUpdateResource.call(this, identifier, payload); + var resource = this.resources[identifier]; + if (resource && resource.mainResource && resource.finished) + document.title = WebInspector.UIString("Developer Tools - %s", resource.url); + }; +})(); + + +// Highlight extension content scripts in the scripts list. +(function () { + var original = WebInspector.ScriptsPanel.prototype._addScriptToFilesMenu; + WebInspector.ScriptsPanel.prototype._addScriptToFilesMenu = function(script) + { + var result = original.apply(this, arguments); + var debuggerAgent = devtools.tools.getDebuggerAgent(); + var type = debuggerAgent.getScriptContextType(script.sourceID); + var option = script.filesSelectOption; + if (type === "injected" && option) + option.addStyleClass("injected"); + return result; + }; +})(); + + +/** Pending WebKit upstream by apavlov). Fixes iframe vs drag problem. */ +(function() +{ + var originalDragStart = WebInspector.elementDragStart; + WebInspector.elementDragStart = function(element) + { + if (element) { + var glassPane = document.createElement("div"); + glassPane.style.cssText = "position:absolute;width:100%;height:100%;opacity:0;z-index:1"; + glassPane.id = "glass-pane-for-drag"; + element.parentElement.appendChild(glassPane); + } + + originalDragStart.apply(this, arguments); + }; + + var originalDragEnd = WebInspector.elementDragEnd; + WebInspector.elementDragEnd = function() + { + originalDragEnd.apply(this, arguments); + + var glassPane = document.getElementById("glass-pane-for-drag"); + if (glassPane) + glassPane.parentElement.removeChild(glassPane); + }; +})(); + + +(function () { +var orig = InjectedScriptAccess.prototype.getProperties; +InjectedScriptAccess.prototype.getProperties = function(objectProxy, ignoreHasOwnProperty, abbreviate, callback) +{ + if (objectProxy.isScope) + devtools.tools.getDebuggerAgent().resolveScope(objectProxy.objectId, callback); + else if (objectProxy.isV8Ref) + devtools.tools.getDebuggerAgent().resolveChildren(objectProxy.objectId, callback, false); + else + orig.apply(this, arguments); +}; +})(); + + +(function() +{ +InjectedScriptAccess.prototype.evaluateInCallFrame = function(callFrameId, code, objectGroup, callback) +{ + //TODO(pfeldman): remove once 49084 is rolled. + if (!callback) + callback = objectGroup; + devtools.tools.getDebuggerAgent().evaluateInCallFrame(callFrameId, code, callback); +}; +})(); + + +WebInspector.resourceTrackingWasEnabled = function() +{ + InspectorBackend._resourceTrackingEnabled = true; + this.panels.resources.resourceTrackingWasEnabled(); +}; + +WebInspector.resourceTrackingWasDisabled = function() +{ + InspectorBackend._resourceTrackingEnabled = false; + this.panels.resources.resourceTrackingWasDisabled(); +}; + +(function() +{ +var orig = WebInspector.ConsoleMessage.prototype.setMessageBody; +WebInspector.ConsoleMessage.prototype.setMessageBody = function(args) +{ + for (var i = 0; i < args.length; ++i) { + if (typeof args[i] === "string") + args[i] = WebInspector.ObjectProxy.wrapPrimitiveValue(args[i]); + } + orig.call(this, args); +}; +})(); + + +(function() +{ +var orig = InjectedScriptAccess.prototype.getCompletions; +InjectedScriptAccess.prototype.getCompletions = function(expressionString, includeInspectorCommandLineAPI, callFrameId, reportCompletions) +{ + if (typeof callFrameId === "number") + devtools.tools.getDebuggerAgent().resolveCompletionsOnFrame(expressionString, callFrameId, reportCompletions); + else + return orig.apply(this, arguments); +}; +})(); + + +(function() +{ +WebInspector.ElementsPanel.prototype._nodeSearchButtonClicked = function( event) +{ + InspectorBackend.toggleNodeSearch(); + this.nodeSearchButton.toggled = !this.nodeSearchButton.toggled; +}; +})(); + + +// We need to have a place for postponed tasks +// which should be executed when all the messages between agent and frontend +// are processed. + +WebInspector.runAfterPendingDispatchesQueue = []; + +WebInspector.TestController.prototype.runAfterPendingDispatches = function(callback) +{ + WebInspector.runAfterPendingDispatchesQueue.push(callback); +}; + +WebInspector.queuesAreEmpty = function() +{ + var copy = this.runAfterPendingDispatchesQueue.slice(); + this.runAfterPendingDispatchesQueue = []; + for (var i = 0; i < copy.length; ++i) + copy[i].call(this); +}; + +(function() +{ +var originalAddToFrame = InspectorFrontendHost.addResourceSourceToFrame; +InspectorFrontendHost.addResourceSourceToFrame = function(identifier, element) +{ + var resource = WebInspector.resources[identifier]; + if (!resource) + return; + originalAddToFrame.call(this, identifier, resource.mimeType, element); +}; +})(); + +WebInspector.pausedScript = function(callFrames) +{ + this.panels.scripts.debuggerPaused(callFrames); +}; diff --git a/WebKit/chromium/src/js/DevToolsHostStub.js b/WebKit/chromium/src/js/DevToolsHostStub.js new file mode 100644 index 0000000..8b2f46b --- /dev/null +++ b/WebKit/chromium/src/js/DevToolsHostStub.js @@ -0,0 +1,309 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** + * @fileoverview These stubs emulate backend functionality and allows + * DevTools frontend to function as a standalone web app. + */ + +if (!window["RemoteDebuggerAgent"]) { + +/** + * FIXME: change field naming style to use trailing underscore. + * @constructor + */ +RemoteDebuggerAgentStub = function() +{ +}; + + +RemoteDebuggerAgentStub.prototype.getContextId = function() +{ + RemoteDebuggerAgent.setContextId(3); +}; + + +RemoteDebuggerAgentStub.prototype.processDebugCommands = function() +{ +}; + + +/** + * @constructor + */ +RemoteProfilerAgentStub = function() +{ +}; + + +RemoteProfilerAgentStub.prototype.getActiveProfilerModules = function() +{ + ProfilerStubHelper.GetInstance().getActiveProfilerModules(); +}; + + +RemoteProfilerAgentStub.prototype.getLogLines = function(pos) +{ + ProfilerStubHelper.GetInstance().getLogLines(pos); +}; + + +/** + * @constructor + */ +RemoteToolsAgentStub = function() +{ +}; + + +RemoteToolsAgentStub.prototype.dispatchOnInjectedScript = function() +{ +}; + + +RemoteToolsAgentStub.prototype.dispatchOnInspectorController = function() +{ +}; + + +/** + * @constructor + */ +ProfilerStubHelper = function() +{ + this.activeProfilerModules_ = devtools.ProfilerAgent.ProfilerModules.PROFILER_MODULE_NONE; + this.heapProfSample_ = 0; + this.log_ = ''; +}; + + +ProfilerStubHelper.GetInstance = function() +{ + if (!ProfilerStubHelper.instance_) + ProfilerStubHelper.instance_ = new ProfilerStubHelper(); + return ProfilerStubHelper.instance_; +}; + + +ProfilerStubHelper.prototype.StopProfiling = function(modules) +{ + this.activeProfilerModules_ &= ~modules; +}; + + +ProfilerStubHelper.prototype.StartProfiling = function(modules) +{ + var profModules = devtools.ProfilerAgent.ProfilerModules; + if (modules & profModules.PROFILER_MODULE_HEAP_SNAPSHOT) { + if (modules & profModules.PROFILER_MODULE_HEAP_STATS) { + this.log_ += + 'heap-sample-begin,"Heap","allocated",' + + (new Date()).getTime() + '\n' + + 'heap-sample-stats,"Heap","allocated",10000,1000\n'; + this.log_ += + 'heap-sample-item,STRING_TYPE,100,1000\n' + + 'heap-sample-item,CODE_TYPE,10,200\n' + + 'heap-sample-item,MAP_TYPE,20,350\n'; + this.log_ += ProfilerStubHelper.HeapSamples[this.heapProfSample_++]; + this.heapProfSample_ %= ProfilerStubHelper.HeapSamples.length; + this.log_ += 'heap-sample-end,"Heap","allocated"\n'; + } + } else { + if (modules & profModules.PROFILER_MODULE_CPU) + this.log_ += ProfilerStubHelper.ProfilerLogBuffer; + this.activeProfilerModules_ |= modules; + } +}; + + +ProfilerStubHelper.prototype.getActiveProfilerModules = function() +{ + var self = this; + setTimeout(function() { + RemoteProfilerAgent.didGetActiveProfilerModules(self.activeProfilerModules_); + }, 100); +}; + + +ProfilerStubHelper.prototype.getLogLines = function(pos) +{ + var profModules = devtools.ProfilerAgent.ProfilerModules; + var logLines = this.log_.substr(pos); + setTimeout(function() { + RemoteProfilerAgent.didGetLogLines(pos + logLines.length, logLines); + }, 100); +}; + + +ProfilerStubHelper.ProfilerLogBuffer = + 'profiler,begin,1\n' + + 'profiler,resume\n' + + 'code-creation,LazyCompile,0x1000,256,"test1 http://aaa.js:1"\n' + + 'code-creation,LazyCompile,0x2000,256,"test2 http://bbb.js:2"\n' + + 'code-creation,LazyCompile,0x3000,256,"test3 http://ccc.js:3"\n' + + 'tick,0x1010,0x0,3\n' + + 'tick,0x2020,0x0,3,0x1010\n' + + 'tick,0x2020,0x0,3,0x1010\n' + + 'tick,0x3010,0x0,3,0x2020, 0x1010\n' + + 'tick,0x2020,0x0,3,0x1010\n' + + 'tick,0x2030,0x0,3,0x2020, 0x1010\n' + + 'tick,0x2020,0x0,3,0x1010\n' + + 'tick,0x1010,0x0,3\n' + + 'profiler,pause\n'; + + +ProfilerStubHelper.HeapSamples = [ + 'heap-js-cons-item,foo,1,100\n' + + 'heap-js-cons-item,bar,20,2000\n' + + 'heap-js-cons-item,Object,5,100\n' + + 'heap-js-ret-item,foo,bar;3\n' + + 'heap-js-ret-item,bar,foo;5\n' + + 'heap-js-ret-item,Object:0x1234,(roots);1\n', + + 'heap-js-cons-item,foo,2000,200000\n' + + 'heap-js-cons-item,bar,10,1000\n' + + 'heap-js-cons-item,Object,6,120\n' + + 'heap-js-ret-item,foo,bar;7,Object:0x1234;10\n' + + 'heap-js-ret-item,bar,foo;10,Object:0x1234;10\n' + + 'heap-js-ret-item,Object:0x1234,(roots);1\n', + + 'heap-js-cons-item,foo,15,1500\n' + + 'heap-js-cons-item,bar,15,1500\n' + + 'heap-js-cons-item,Object,5,100\n' + + 'heap-js-cons-item,Array,3,1000\n' + + 'heap-js-ret-item,foo,bar;3,Array:0x5678;1\n' + + 'heap-js-ret-item,bar,foo;5,Object:0x1234;8,Object:0x5678;2\n' + + 'heap-js-ret-item,Object:0x1234,(roots);1,Object:0x5678;2\n' + + 'heap-js-ret-item,Object:0x5678,(global property);3,Object:0x1234;5\n' + + 'heap-js-ret-item,Array:0x5678,(global property);3,Array:0x5678;2\n', + + 'heap-js-cons-item,bar,20,2000\n' + + 'heap-js-cons-item,Object,6,120\n' + + 'heap-js-ret-item,bar,foo;5,Object:0x1234;1,Object:0x1235;3\n' + + 'heap-js-ret-item,Object:0x1234,(global property);3\n' + + 'heap-js-ret-item,Object:0x1235,(global property);5\n', + + 'heap-js-cons-item,foo,15,1500\n' + + 'heap-js-cons-item,bar,15,1500\n' + + 'heap-js-cons-item,Array,10,1000\n' + + 'heap-js-ret-item,foo,bar;1,Array:0x5678;1\n' + + 'heap-js-ret-item,bar,foo;5\n' + + 'heap-js-ret-item,Array:0x5678,(roots);3\n', + + 'heap-js-cons-item,bar,20,2000\n' + + 'heap-js-cons-item,baz,15,1500\n' + + 'heap-js-ret-item,bar,baz;3\n' + + 'heap-js-ret-item,baz,bar;3\n' +]; + + +/** + * @constructor + */ +RemoteDebuggerCommandExecutorStub = function() +{ +}; + + +RemoteDebuggerCommandExecutorStub.prototype.DebuggerCommand = function(cmd) +{ + if ('{"seq":2,"type":"request","command":"scripts","arguments":{"includeSource":false}}' === cmd) { + var response1 = + '{"seq":5,"request_seq":2,"type":"response","command":"scripts","' + + 'success":true,"body":[{"handle":61,"type":"script","name":"' + + 'http://www/~test/t.js","id":59,"lineOffset":0,"columnOffset":0,' + + '"lineCount":1,"sourceStart":"function fib(n) {","sourceLength":300,' + + '"scriptType":2,"compilationType":0,"context":{"ref":60}}],"refs":[{' + + '"handle":60,"type":"context","data":"page,3"}],"running":false}'; + this.sendResponse_(response1); + } else if ('{"seq":3,"type":"request","command":"scripts","arguments":{"ids":[59],"includeSource":true}}' === cmd) { + this.sendResponse_( + '{"seq":8,"request_seq":3,"type":"response","command":"scripts",' + + '"success":true,"body":[{"handle":1,"type":"script","name":' + + '"http://www/~test/t.js","id":59,"lineOffset":0,"columnOffset":0,' + + '"lineCount":1,"source":"function fib(n) {return n+1;}",' + + '"sourceLength":244,"scriptType":2,"compilationType":0,"context":{' + + '"ref":0}}],"refs":[{"handle":0,"type":"context","data":"page,3}],"' + + '"running":false}'); + } else if (cmd.indexOf('"command":"profile"') !== -1) { + var cmdObj = JSON.parse(cmd); + if (cmdObj.arguments.command === "resume") + ProfilerStubHelper.GetInstance().StartProfiling(parseInt(cmdObj.arguments.modules)); + else if (cmdObj.arguments.command === "pause") + ProfilerStubHelper.GetInstance().StopProfiling(parseInt(cmdObj.arguments.modules)); + else + debugPrint("Unexpected profile command: " + cmdObj.arguments.command); + } else + debugPrint("Unexpected command: " + cmd); +}; + + +RemoteDebuggerCommandExecutorStub.prototype.DebuggerPauseScript = function() +{ +}; + + +RemoteDebuggerCommandExecutorStub.prototype.sendResponse_ = function(response) +{ + setTimeout(function() { + RemoteDebuggerAgent.debuggerOutput(response); + }, 0); +}; + + +DevToolsHostStub = function() +{ + this.isStub = true; +}; +DevToolsHostStub.prototype.__proto__ = WebInspector.InspectorFrontendHostStub.prototype; + + +DevToolsHostStub.prototype.reset = function() +{ +}; + + +DevToolsHostStub.prototype.setting = function() +{ +}; + + +DevToolsHostStub.prototype.setSetting = function() +{ +}; + + +window["RemoteDebuggerAgent"] = new RemoteDebuggerAgentStub(); +window["RemoteDebuggerCommandExecutor"] = new RemoteDebuggerCommandExecutorStub(); +window["RemoteProfilerAgent"] = new RemoteProfilerAgentStub(); +window["RemoteToolsAgent"] = new RemoteToolsAgentStub(); +InspectorFrontendHost = new DevToolsHostStub(); + +} diff --git a/WebKit/chromium/src/js/HeapProfilerPanel.js b/WebKit/chromium/src/js/HeapProfilerPanel.js new file mode 100644 index 0000000..abbf580 --- /dev/null +++ b/WebKit/chromium/src/js/HeapProfilerPanel.js @@ -0,0 +1,966 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** + * @fileoverview Heap profiler panel implementation. + */ + +WebInspector.ProfilesPanel.prototype.addSnapshot = function(snapshot) { + snapshot.title = WebInspector.UIString("Snapshot %d", snapshot.number); + snapshot.typeId = WebInspector.HeapSnapshotProfileType.TypeId; + + var snapshots = WebInspector.HeapSnapshotProfileType.snapshots; + snapshots.push(snapshot); + + snapshot.listIndex = snapshots.length - 1; + + if (WebInspector.CPUProfile) + this.addProfileHeader(WebInspector.HeapSnapshotProfileType.TypeId, snapshot); + else + this.addProfileHeader(snapshot); + + this.dispatchEventToListeners("snapshot added"); +} + + +WebInspector.HeapSnapshotView = function(parent, profile) +{ + WebInspector.View.call(this); + + this.element.addStyleClass("heap-snapshot-view"); + + this.parent = parent; + this.parent.addEventListener("snapshot added", this._updateBaseOptions, this); + + this.showCountAsPercent = false; + this.showSizeAsPercent = false; + this.showCountDeltaAsPercent = false; + this.showSizeDeltaAsPercent = false; + + this.categories = { + code: new WebInspector.ResourceCategory("code", WebInspector.UIString("Code"), "rgb(255,121,0)"), + data: new WebInspector.ResourceCategory("data", WebInspector.UIString("Objects"), "rgb(47,102,236)") + }; + + var summaryContainer = document.createElement("div"); + summaryContainer.id = "heap-snapshot-summary-container"; + + this.countsSummaryBar = new WebInspector.SummaryBar(this.categories); + this.countsSummaryBar.element.className = "heap-snapshot-summary"; + this.countsSummaryBar.calculator = new WebInspector.HeapSummaryCountCalculator(); + var countsLabel = document.createElement("div"); + countsLabel.className = "heap-snapshot-summary-label"; + countsLabel.textContent = WebInspector.UIString("Count"); + this.countsSummaryBar.element.appendChild(countsLabel); + summaryContainer.appendChild(this.countsSummaryBar.element); + + this.sizesSummaryBar = new WebInspector.SummaryBar(this.categories); + this.sizesSummaryBar.element.className = "heap-snapshot-summary"; + this.sizesSummaryBar.calculator = new WebInspector.HeapSummarySizeCalculator(); + var sizesLabel = document.createElement("label"); + sizesLabel.className = "heap-snapshot-summary-label"; + sizesLabel.textContent = WebInspector.UIString("Size"); + this.sizesSummaryBar.element.appendChild(sizesLabel); + summaryContainer.appendChild(this.sizesSummaryBar.element); + + this.element.appendChild(summaryContainer); + + var columns = { "cons": { title: WebInspector.UIString("Constructor"), disclosure: true, sortable: true }, + "count": { title: WebInspector.UIString("Count"), width: "54px", sortable: true }, + "size": { title: WebInspector.UIString("Size"), width: "72px", sort: "descending", sortable: true }, + "countDelta": { title: WebInspector.UIString("\xb1 Count"), width: "72px", sortable: true }, + "sizeDelta": { title: WebInspector.UIString("\xb1 Size"), width: "72px", sortable: true } }; + + this.dataGrid = new WebInspector.DataGrid(columns); + this.dataGrid.addEventListener("sorting changed", this._sortData, this); + this.dataGrid.element.addEventListener("mousedown", this._mouseDownInDataGrid.bind(this), true); + this.element.appendChild(this.dataGrid.element); + + this.profile = profile; + + this.baseSelectElement = document.createElement("select"); + this.baseSelectElement.className = "status-bar-item"; + this.baseSelectElement.addEventListener("change", this._changeBase.bind(this), false); + this._updateBaseOptions(); + if (this.profile.listIndex > 0) + this.baseSelectElement.selectedIndex = this.profile.listIndex - 1; + else + this.baseSelectElement.selectedIndex = this.profile.listIndex; + this._resetDataGridList(); + + this.percentButton = new WebInspector.StatusBarButton("", "percent-time-status-bar-item status-bar-item"); + this.percentButton.addEventListener("click", this._percentClicked.bind(this), false); + + this.refresh(); + + this._updatePercentButton(); +}; + +WebInspector.HeapSnapshotView.prototype = { + + get statusBarItems() + { + return [this.baseSelectElement, this.percentButton.element]; + }, + + get profile() + { + return this._profile; + }, + + set profile(profile) + { + this._profile = profile; + }, + + show: function(parentElement) + { + WebInspector.View.prototype.show.call(this, parentElement); + this.dataGrid.updateWidths(); + }, + + hide: function() + { + WebInspector.View.prototype.hide.call(this); + this._currentSearchResultIndex = -1; + }, + + resize: function() + { + if (this.dataGrid) + this.dataGrid.updateWidths(); + }, + + refresh: function() + { + this.dataGrid.removeChildren(); + + var children = this.snapshotDataGridList.children; + var count = children.length; + for (var index = 0; index < count; ++index) + this.dataGrid.appendChild(children[index]); + + this._updateSummaryGraph(); + }, + + refreshShowAsPercents: function() + { + this._updatePercentButton(); + this.refreshVisibleData(); + }, + + _deleteSearchMatchedFlags: function(node) + { + delete node._searchMatchedConsColumn; + delete node._searchMatchedCountColumn; + delete node._searchMatchedSizeColumn; + delete node._searchMatchedCountDeltaColumn; + delete node._searchMatchedSizeDeltaColumn; + }, + + searchCanceled: function() + { + if (this._searchResults) { + for (var i = 0; i < this._searchResults.length; ++i) { + var profileNode = this._searchResults[i].profileNode; + this._deleteSearchMatchedFlags(profileNode); + profileNode.refresh(); + } + } + + delete this._searchFinishedCallback; + this._currentSearchResultIndex = -1; + this._searchResults = []; + }, + + performSearch: function(query, finishedCallback) + { + // Call searchCanceled since it will reset everything we need before doing a new search. + this.searchCanceled(); + + query = query.trimWhitespace(); + + if (!query.length) + return; + + this._searchFinishedCallback = finishedCallback; + + var helper = WebInspector.HeapSnapshotView.SearchHelper; + + var operationAndNumber = helper.parseOperationAndNumber(query); + var operation = operationAndNumber[0]; + var queryNumber = operationAndNumber[1]; + + var percentUnits = helper.percents.test(query); + var megaBytesUnits = helper.megaBytes.test(query); + var kiloBytesUnits = helper.kiloBytes.test(query); + var bytesUnits = helper.bytes.test(query); + + var queryNumberBytes = (megaBytesUnits ? (queryNumber * 1024 * 1024) : (kiloBytesUnits ? (queryNumber * 1024) : queryNumber)); + + function matchesQuery(heapSnapshotDataGridNode) + { + WebInspector.HeapSnapshotView.prototype._deleteSearchMatchedFlags(heapSnapshotDataGridNode); + + if (percentUnits) { + heapSnapshotDataGridNode._searchMatchedCountColumn = operation(heapSnapshotDataGridNode.countPercent, queryNumber); + heapSnapshotDataGridNode._searchMatchedSizeColumn = operation(heapSnapshotDataGridNode.sizePercent, queryNumber); + heapSnapshotDataGridNode._searchMatchedCountDeltaColumn = operation(heapSnapshotDataGridNode.countDeltaPercent, queryNumber); + heapSnapshotDataGridNode._searchMatchedSizeDeltaColumn = operation(heapSnapshotDataGridNode.sizeDeltaPercent, queryNumber); + } else if (megaBytesUnits || kiloBytesUnits || bytesUnits) { + heapSnapshotDataGridNode._searchMatchedSizeColumn = operation(heapSnapshotDataGridNode.size, queryNumberBytes); + heapSnapshotDataGridNode._searchMatchedSizeDeltaColumn = operation(heapSnapshotDataGridNode.sizeDelta, queryNumberBytes); + } else { + heapSnapshotDataGridNode._searchMatchedCountColumn = operation(heapSnapshotDataGridNode.count, queryNumber); + heapSnapshotDataGridNode._searchMatchedCountDeltaColumn = operation(heapSnapshotDataGridNode.countDelta, queryNumber); + } + + if (heapSnapshotDataGridNode.constructorName.hasSubstring(query, true)) + heapSnapshotDataGridNode._searchMatchedConsColumn = true; + + if (heapSnapshotDataGridNode._searchMatchedConsColumn || + heapSnapshotDataGridNode._searchMatchedCountColumn || + heapSnapshotDataGridNode._searchMatchedSizeColumn || + heapSnapshotDataGridNode._searchMatchedCountDeltaColumn || + heapSnapshotDataGridNode._searchMatchedSizeDeltaColumn) { + heapSnapshotDataGridNode.refresh(); + return true; + } + + return false; + } + + var current = this.snapshotDataGridList.children[0]; + var depth = 0; + var info = {}; + + // The second and subsequent levels of heap snapshot nodes represent retainers, + // so recursive expansion will be infinite, since a graph is being traversed. + // So default to a recursion cap of 2 levels. + var maxDepth = 2; + + while (current) { + if (matchesQuery(current)) + this._searchResults.push({ profileNode: current }); + current = current.traverseNextNode(false, null, (depth >= maxDepth), info); + depth += info.depthChange; + } + + finishedCallback(this, this._searchResults.length); + }, + + jumpToFirstSearchResult: WebInspector.CPUProfileView.prototype.jumpToFirstSearchResult, + jumpToLastSearchResult: WebInspector.CPUProfileView.prototype.jumpToLastSearchResult, + jumpToNextSearchResult: WebInspector.CPUProfileView.prototype.jumpToNextSearchResult, + jumpToPreviousSearchResult: WebInspector.CPUProfileView.prototype.jumpToPreviousSearchResult, + showingFirstSearchResult: WebInspector.CPUProfileView.prototype.showingFirstSearchResult, + showingLastSearchResult: WebInspector.CPUProfileView.prototype.showingLastSearchResult, + _jumpToSearchResult: WebInspector.CPUProfileView.prototype._jumpToSearchResult, + + refreshVisibleData: function() + { + var child = this.dataGrid.children[0]; + while (child) { + child.refresh(); + child = child.traverseNextNode(false, null, true); + } + this._updateSummaryGraph(); + }, + + _changeBase: function() { + if (this.baseSnapshot === WebInspector.HeapSnapshotProfileType.snapshots[this.baseSelectElement.selectedIndex]) + return; + + this._resetDataGridList(); + this.refresh(); + + if (!this.currentQuery || !this._searchFinishedCallback || !this._searchResults) + return; + + // The current search needs to be performed again. First negate out previous match + // count by calling the search finished callback with a negative number of matches. + // Then perform the search again with the same query and callback. + this._searchFinishedCallback(this, -this._searchResults.length); + this.performSearch(this.currentQuery, this._searchFinishedCallback); + }, + + _createSnapshotDataGridList: function() + { + if (this._snapshotDataGridList) + delete this._snapshotDataGridList; + + this._snapshotDataGridList = new WebInspector.HeapSnapshotDataGridList(this, this.baseSnapshot.entries, this.profile.entries); + return this._snapshotDataGridList; + }, + + _mouseDownInDataGrid: function(event) + { + if (event.detail < 2) + return; + + var cell = event.target.enclosingNodeOrSelfWithNodeName("td"); + if (!cell || (!cell.hasStyleClass("count-column") && !cell.hasStyleClass("size-column") && !cell.hasStyleClass("countDelta-column") && !cell.hasStyleClass("sizeDelta-column"))) + return; + + if (cell.hasStyleClass("count-column")) + this.showCountAsPercent = !this.showCountAsPercent; + else if (cell.hasStyleClass("size-column")) + this.showSizeAsPercent = !this.showSizeAsPercent; + else if (cell.hasStyleClass("countDelta-column")) + this.showCountDeltaAsPercent = !this.showCountDeltaAsPercent; + else if (cell.hasStyleClass("sizeDelta-column")) + this.showSizeDeltaAsPercent = !this.showSizeDeltaAsPercent; + + this.refreshShowAsPercents(); + + event.preventDefault(); + event.stopPropagation(); + }, + + get _isShowingAsPercent() + { + return this.showCountAsPercent && this.showSizeAsPercent && this.showCountDeltaAsPercent && this.showSizeDeltaAsPercent; + }, + + _percentClicked: function(event) + { + var currentState = this._isShowingAsPercent; + this.showCountAsPercent = !currentState; + this.showSizeAsPercent = !currentState; + this.showCountDeltaAsPercent = !currentState; + this.showSizeDeltaAsPercent = !currentState; + this.refreshShowAsPercents(); + }, + + _resetDataGridList: function() + { + this.baseSnapshot = WebInspector.HeapSnapshotProfileType.snapshots[this.baseSelectElement.selectedIndex]; + var lastComparator = WebInspector.HeapSnapshotDataGridList.propertyComparator("size", false); + if (this.snapshotDataGridList) + lastComparator = this.snapshotDataGridList.lastComparator; + this.snapshotDataGridList = this._createSnapshotDataGridList(); + this.snapshotDataGridList.sort(lastComparator, true); + }, + + _sortData: function() + { + var sortAscending = this.dataGrid.sortOrder === "ascending"; + var sortColumnIdentifier = this.dataGrid.sortColumnIdentifier; + var sortProperty = { + "cons": ["constructorName", null], + "count": ["count", null], + "size": ["size", "count"], + "countDelta": this.showCountDeltaAsPercent ? ["countDeltaPercent", null] : ["countDelta", null], + "sizeDelta": this.showSizeDeltaAsPercent ? ["sizeDeltaPercent", "countDeltaPercent"] : ["sizeDelta", "sizeDeltaPercent"] + }[sortColumnIdentifier]; + + this.snapshotDataGridList.sort(WebInspector.HeapSnapshotDataGridList.propertyComparator(sortProperty[0], sortProperty[1], sortAscending)); + + this.refresh(); + }, + + _updateBaseOptions: function() + { + var list = WebInspector.HeapSnapshotProfileType.snapshots; + // We're assuming that snapshots can only be added. + if (this.baseSelectElement.length === list.length) + return; + + for (var i = this.baseSelectElement.length, n = list.length; i < n; ++i) { + var baseOption = document.createElement("option"); + baseOption.label = WebInspector.UIString("Compared to %s", list[i].title); + this.baseSelectElement.appendChild(baseOption); + } + }, + + _updatePercentButton: function() + { + if (this._isShowingAsPercent) { + this.percentButton.title = WebInspector.UIString("Show absolute counts and sizes."); + this.percentButton.toggled = true; + } else { + this.percentButton.title = WebInspector.UIString("Show counts and sizes as percentages."); + this.percentButton.toggled = false; + } + }, + + _updateSummaryGraph: function() + { + this.countsSummaryBar.calculator.showAsPercent = this._isShowingAsPercent; + this.countsSummaryBar.update(this.profile.lowlevels); + + this.sizesSummaryBar.calculator.showAsPercent = this._isShowingAsPercent; + this.sizesSummaryBar.update(this.profile.lowlevels); + } +}; + +WebInspector.HeapSnapshotView.prototype.__proto__ = WebInspector.View.prototype; + +WebInspector.HeapSnapshotView.SearchHelper = { + // In comparators, we assume that a value from a node is passed as the first parameter. + operations: { LESS: function (a, b) { return a !== null && a < b; }, + LESS_OR_EQUAL: function (a, b) { return a !== null && a <= b; }, + EQUAL: function (a, b) { return a !== null && a === b; }, + GREATER_OR_EQUAL: function (a, b) { return a !== null && a >= b; }, + GREATER: function (a, b) { return a !== null && a > b; } }, + + operationParsers: { LESS: /^<(\d+)/, + LESS_OR_EQUAL: /^<=(\d+)/, + GREATER_OR_EQUAL: /^>=(\d+)/, + GREATER: /^>(\d+)/ }, + + parseOperationAndNumber: function(query) + { + var operations = WebInspector.HeapSnapshotView.SearchHelper.operations; + var parsers = WebInspector.HeapSnapshotView.SearchHelper.operationParsers; + for (var operation in parsers) { + var match = query.match(parsers[operation]); + if (match !== null) + return [operations[operation], parseFloat(match[1])]; + } + return [operations.EQUAL, parseFloat(query)]; + }, + + percents: /%$/, + + megaBytes: /MB$/i, + + kiloBytes: /KB$/i, + + bytes: /B$/i +} + +WebInspector.HeapSummaryCalculator = function(lowLevelField) +{ + this.total = 1; + this.lowLevelField = lowLevelField; +} + +WebInspector.HeapSummaryCalculator.prototype = { + computeSummaryValues: function(lowLevels) + { + var highLevels = {data: 0, code: 0}; + this.total = 0; + for (var item in lowLevels) { + var highItem = this._highFromLow(item); + if (highItem) { + var value = lowLevels[item][this.lowLevelField]; + highLevels[highItem] += value; + this.total += value; + } + } + var result = {categoryValues: highLevels}; + if (!this.showAsPercent) + result.total = this.total; + return result; + }, + + formatValue: function(value) + { + if (this.showAsPercent) + return WebInspector.UIString("%.2f%%", value / this.total * 100.0); + else + return this._valueToString(value); + }, + + get showAsPercent() + { + return this._showAsPercent; + }, + + set showAsPercent(x) + { + this._showAsPercent = x; + } +} + +WebInspector.HeapSummaryCountCalculator = function() +{ + WebInspector.HeapSummaryCalculator.call(this, "count"); +} + +WebInspector.HeapSummaryCountCalculator.prototype = { + _highFromLow: function(type) { + if (type === "CODE_TYPE" || type === "SHARED_FUNCTION_INFO_TYPE" || type === "SCRIPT_TYPE") return "code"; + if (type === "STRING_TYPE" || type === "HEAP_NUMBER_TYPE" || type.match(/^JS_/)) return "data"; + return null; + }, + + _valueToString: function(value) { + return value.toString(); + } +} + +WebInspector.HeapSummaryCountCalculator.prototype.__proto__ = WebInspector.HeapSummaryCalculator.prototype; + +WebInspector.HeapSummarySizeCalculator = function() +{ + WebInspector.HeapSummaryCalculator.call(this, "size"); +} + +WebInspector.HeapSummarySizeCalculator.prototype = { + _highFromLow: function(type) { + if (type === "CODE_TYPE" || type === "SHARED_FUNCTION_INFO_TYPE" || type === "SCRIPT_TYPE") return "code"; + if (type === "STRING_TYPE" || type === "HEAP_NUMBER_TYPE" || type.match(/^JS_/) || type.match(/_ARRAY_TYPE$/)) return "data"; + return null; + }, + + _valueToString: Number.bytesToString +} + +WebInspector.HeapSummarySizeCalculator.prototype.__proto__ = WebInspector.HeapSummaryCalculator.prototype; + +WebInspector.HeapSnapshotSidebarTreeElement = function(snapshot) +{ + this.profile = snapshot; + + WebInspector.SidebarTreeElement.call(this, "heap-snapshot-sidebar-tree-item", "", "", snapshot, false); + + this.refreshTitles(); +}; + +WebInspector.HeapSnapshotSidebarTreeElement.prototype = { + get mainTitle() + { + if (this._mainTitle) + return this._mainTitle; + return this.profile.title; + }, + + set mainTitle(x) + { + this._mainTitle = x; + this.refreshTitles(); + } +}; + +WebInspector.HeapSnapshotSidebarTreeElement.prototype.__proto__ = WebInspector.ProfileSidebarTreeElement.prototype; + +WebInspector.HeapSnapshotDataGridNodeWithRetainers = function(owningTree) +{ + this.tree = owningTree; + + WebInspector.DataGridNode.call(this, null, this._hasRetainers); + + this.addEventListener("populate", this._populate, this); +}; + +WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype = { + isEmptySet: function(set) + { + for (var x in set) + return false; + return true; + }, + + get _hasRetainers() + { + return !this.isEmptySet(this.retainers); + }, + + get _parent() + { + // For top-level nodes, return owning tree as a parent, not data grid. + return this.parent !== this.dataGrid ? this.parent : this.tree; + }, + + _populate: function(event) + { + var self = this; + this.produceDiff(this.baseRetainers, this.retainers, function(baseItem, snapshotItem) { + self.appendChild(new WebInspector.HeapSnapshotDataGridRetainerNode(self.snapshotView, baseItem, snapshotItem, self.tree)); + }); + + if (this._parent) { + var currentComparator = this._parent.lastComparator; + if (currentComparator) + this.sort(currentComparator, true); + } + + this.removeEventListener("populate", this._populate, this); + }, + + produceDiff: function(baseEntries, currentEntries, callback) + { + for (var item in currentEntries) + callback(baseEntries[item], currentEntries[item]); + + for (item in baseEntries) { + if (!(item in currentEntries)) + callback(baseEntries[item], null); + } + }, + + sort: function(comparator, force) { + if (!force && this.lastComparator === comparator) + return; + + this.children.sort(comparator); + var childCount = this.children.length; + for (var childIndex = 0; childIndex < childCount; ++childIndex) + this.children[childIndex]._recalculateSiblings(childIndex); + for (var i = 0; i < this.children.length; ++i) { + var child = this.children[i]; + if (!force && (!child.expanded || child.lastComparator === comparator)) + continue; + child.sort(comparator, force); + } + this.lastComparator = comparator; + }, + + signForDelta: function(delta) { + if (delta === 0) + return ""; + if (delta > 0) + return "+"; + else + // Math minus sign, same width as plus. + return "\u2212"; + }, + + showDeltaAsPercent: function(value) { + if (value === Number.POSITIVE_INFINITY) + return WebInspector.UIString("new"); + else if (value === Number.NEGATIVE_INFINITY) + return WebInspector.UIString("deleted"); + if (value > 1000.0) + return WebInspector.UIString("%s >1000%%", this.signForDelta(value)); + return WebInspector.UIString("%s%.2f%%", this.signForDelta(value), Math.abs(value)); + }, + + getTotalCount: function() { + if (!this._count) { + this._count = 0; + for (var i = 0, n = this.children.length; i < n; ++i) + this._count += this.children[i].count; + } + return this._count; + }, + + getTotalSize: function() { + if (!this._size) { + this._size = 0; + for (var i = 0, n = this.children.length; i < n; ++i) + this._size += this.children[i].size; + } + return this._size; + }, + + get countPercent() + { + return this.count / this._parent.getTotalCount() * 100.0; + }, + + get sizePercent() + { + return this.size / this._parent.getTotalSize() * 100.0; + }, + + get countDeltaPercent() + { + if (this.baseCount > 0) { + if (this.count > 0) + return this.countDelta / this.baseCount * 100.0; + else + return Number.NEGATIVE_INFINITY; + } else + return Number.POSITIVE_INFINITY; + }, + + get sizeDeltaPercent() + { + if (this.baseSize > 0) { + if (this.size > 0) + return this.sizeDelta / this.baseSize * 100.0; + else + return Number.NEGATIVE_INFINITY; + } else + return Number.POSITIVE_INFINITY; + }, + + get data() + { + var data = {}; + + data["cons"] = this.constructorName; + + if (this.snapshotView.showCountAsPercent) + data["count"] = WebInspector.UIString("%.2f%%", this.countPercent); + else + data["count"] = this.count; + + if (this.size !== null) { + if (this.snapshotView.showSizeAsPercent) + data["size"] = WebInspector.UIString("%.2f%%", this.sizePercent); + else + data["size"] = Number.bytesToString(this.size); + } else + data["size"] = ""; + + if (this.snapshotView.showCountDeltaAsPercent) + data["countDelta"] = this.showDeltaAsPercent(this.countDeltaPercent); + else + data["countDelta"] = WebInspector.UIString("%s%d", this.signForDelta(this.countDelta), Math.abs(this.countDelta)); + + if (this.sizeDelta !== null) { + if (this.snapshotView.showSizeDeltaAsPercent) + data["sizeDelta"] = this.showDeltaAsPercent(this.sizeDeltaPercent); + else + data["sizeDelta"] = WebInspector.UIString("%s%s", this.signForDelta(this.sizeDelta), Number.bytesToString(Math.abs(this.sizeDelta))); + } else + data["sizeDelta"] = ""; + + return data; + }, + + createCell: function(columnIdentifier) + { + var cell = WebInspector.DataGridNode.prototype.createCell.call(this, columnIdentifier); + + if ((columnIdentifier === "cons" && this._searchMatchedConsColumn) || + (columnIdentifier === "count" && this._searchMatchedCountColumn) || + (columnIdentifier === "size" && this._searchMatchedSizeColumn) || + (columnIdentifier === "countDelta" && this._searchMatchedCountDeltaColumn) || + (columnIdentifier === "sizeDelta" && this._searchMatchedSizeDeltaColumn)) + cell.addStyleClass("highlight"); + + return cell; + } +}; + +WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.__proto__ = WebInspector.DataGridNode.prototype; + +WebInspector.HeapSnapshotDataGridNode = function(snapshotView, baseEntry, snapshotEntry, owningTree) +{ + this.snapshotView = snapshotView; + + if (!snapshotEntry) + snapshotEntry = { cons: baseEntry.cons, count: 0, size: 0, retainers: {} }; + this.constructorName = snapshotEntry.cons; + this.count = snapshotEntry.count; + this.size = snapshotEntry.size; + this.retainers = snapshotEntry.retainers; + + if (!baseEntry) + baseEntry = { count: 0, size: 0, retainers: {} }; + this.baseCount = baseEntry.count; + this.countDelta = this.count - this.baseCount; + this.baseSize = baseEntry.size; + this.sizeDelta = this.size - this.baseSize; + this.baseRetainers = baseEntry.retainers; + + WebInspector.HeapSnapshotDataGridNodeWithRetainers.call(this, owningTree); +}; + +WebInspector.HeapSnapshotDataGridNode.prototype.__proto__ = WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype; + +WebInspector.HeapSnapshotDataGridList = function(snapshotView, baseEntries, snapshotEntries) +{ + this.tree = this; + this.snapshotView = snapshotView; + this.children = []; + this.lastComparator = null; + this.populateChildren(baseEntries, snapshotEntries); +}; + +WebInspector.HeapSnapshotDataGridList.prototype = { + appendChild: function(child) + { + this.insertChild(child, this.children.length); + }, + + insertChild: function(child, index) + { + this.children.splice(index, 0, child); + }, + + removeChildren: function() + { + this.children = []; + }, + + populateChildren: function(baseEntries, snapshotEntries) + { + var self = this; + this.produceDiff(baseEntries, snapshotEntries, function(baseItem, snapshotItem) { + self.appendChild(new WebInspector.HeapSnapshotDataGridNode(self.snapshotView, baseItem, snapshotItem, self)); + }); + }, + + produceDiff: WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.produceDiff, + sort: WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.sort, + getTotalCount: WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.getTotalCount, + getTotalSize: WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.getTotalSize +}; + +WebInspector.HeapSnapshotDataGridList.propertyComparators = [{}, {}]; + +WebInspector.HeapSnapshotDataGridList.propertyComparator = function(property, property2, isAscending) +{ + var propertyHash = property + "#" + property2; + var comparator = this.propertyComparators[(isAscending ? 1 : 0)][propertyHash]; + if (!comparator) { + comparator = function(lhs, rhs) { + var l = lhs[property], r = rhs[property]; + if ((l === null || r === null) && property2 !== null) + l = lhs[property2], r = rhs[property2]; + var result = l < r ? -1 : (l > r ? 1 : 0); + return isAscending ? result : -result; + }; + this.propertyComparators[(isAscending ? 1 : 0)][propertyHash] = comparator; + } + return comparator; +}; + +WebInspector.HeapSnapshotDataGridRetainerNode = function(snapshotView, baseEntry, snapshotEntry, owningTree) +{ + this.snapshotView = snapshotView; + + if (!snapshotEntry) + snapshotEntry = { cons: baseEntry.cons, count: 0, clusters: {} }; + this.constructorName = snapshotEntry.cons; + this.count = snapshotEntry.count; + this.retainers = this._calculateRetainers(this.snapshotView.profile, snapshotEntry.clusters); + + if (!baseEntry) + baseEntry = { count: 0, clusters: {} }; + this.baseCount = baseEntry.count; + this.countDelta = this.count - this.baseCount; + this.baseRetainers = this._calculateRetainers(this.snapshotView.baseSnapshot, baseEntry.clusters); + + this.size = null; + this.sizeDelta = null; + + WebInspector.HeapSnapshotDataGridNodeWithRetainers.call(this, owningTree); +} + +WebInspector.HeapSnapshotDataGridRetainerNode.prototype = { + get sizePercent() + { + return null; + }, + + get sizeDeltaPercent() + { + return null; + }, + + _calculateRetainers: function(snapshot, clusters) { + var retainers = {}; + if (this.isEmptySet(clusters)) { + if (this.constructorName in snapshot.entries) + return snapshot.entries[this.constructorName].retainers; + } else { + // In case when an entry is retained by clusters, we need to gather up the list + // of retainers by merging retainers of every cluster. + // E.g. having such a tree: + // A + // Object:1 10 + // X 3 + // Y 4 + // Object:2 5 + // X 6 + // + // will result in a following retainers list: X 9, Y 4. + for (var clusterName in clusters) { + if (clusterName in snapshot.clusters) { + var clusterRetainers = snapshot.clusters[clusterName].retainers; + for (var clusterRetainer in clusterRetainers) { + var clusterRetainerEntry = clusterRetainers[clusterRetainer]; + if (!(clusterRetainer in retainers)) + retainers[clusterRetainer] = { cons: clusterRetainerEntry.cons, count: 0, clusters: {} }; + retainers[clusterRetainer].count += clusterRetainerEntry.count; + for (var clusterRetainerCluster in clusterRetainerEntry.clusters) + retainers[clusterRetainer].clusters[clusterRetainerCluster] = true; + } + } + } + } + return retainers; + } +}; + +WebInspector.HeapSnapshotDataGridRetainerNode.prototype.__proto__ = WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype; + + +WebInspector.HeapSnapshotProfileType = function() +{ + WebInspector.ProfileType.call(this, WebInspector.HeapSnapshotProfileType.TypeId, WebInspector.UIString("HEAP SNAPSHOTS")); +} + +WebInspector.HeapSnapshotProfileType.TypeId = "HEAP"; + +WebInspector.HeapSnapshotProfileType.snapshots = []; + +WebInspector.HeapSnapshotProfileType.prototype = { + get buttonTooltip() + { + return WebInspector.UIString("Take heap snapshot."); + }, + + get buttonStyle() + { + return "heap-snapshot-status-bar-item status-bar-item"; + }, + + buttonClicked: function() + { + InspectorBackend.takeHeapSnapshot(); + }, + + get welcomeMessage() + { + return WebInspector.UIString("Get a heap snapshot by pressing<br>the %s button on the status bar."); + }, + + createSidebarTreeElementForProfile: function(profile) + { + var element = new WebInspector.HeapSnapshotSidebarTreeElement(profile); + element.small = false; + return element; + }, + + createView: function(profile) + { + return new WebInspector.HeapSnapshotView(WebInspector.panels.profiles, profile); + } +} + +WebInspector.HeapSnapshotProfileType.prototype.__proto__ = WebInspector.ProfileType.prototype; + + +(function() { + var originalCreatePanels = WebInspector._createPanels; + WebInspector._createPanels = function() { + originalCreatePanels.apply(this, arguments); + if (WebInspector.panels.profiles) + WebInspector.panels.profiles.registerProfileType(new WebInspector.HeapSnapshotProfileType()); + } +})(); diff --git a/WebKit/chromium/src/js/Images/segmentChromium.png b/WebKit/chromium/src/js/Images/segmentChromium.png Binary files differnew file mode 100755 index 0000000..607559b --- /dev/null +++ b/WebKit/chromium/src/js/Images/segmentChromium.png diff --git a/WebKit/chromium/src/js/Images/segmentHoverChromium.png b/WebKit/chromium/src/js/Images/segmentHoverChromium.png Binary files differnew file mode 100755 index 0000000..0a743d9 --- /dev/null +++ b/WebKit/chromium/src/js/Images/segmentHoverChromium.png diff --git a/WebKit/chromium/src/js/Images/segmentHoverEndChromium.png b/WebKit/chromium/src/js/Images/segmentHoverEndChromium.png Binary files differnew file mode 100755 index 0000000..cf62072 --- /dev/null +++ b/WebKit/chromium/src/js/Images/segmentHoverEndChromium.png diff --git a/WebKit/chromium/src/js/Images/segmentSelectedChromium.png b/WebKit/chromium/src/js/Images/segmentSelectedChromium.png Binary files differnew file mode 100755 index 0000000..a1f7251 --- /dev/null +++ b/WebKit/chromium/src/js/Images/segmentSelectedChromium.png diff --git a/WebKit/chromium/src/js/Images/segmentSelectedEndChromium.png b/WebKit/chromium/src/js/Images/segmentSelectedEndChromium.png Binary files differnew file mode 100755 index 0000000..07641db --- /dev/null +++ b/WebKit/chromium/src/js/Images/segmentSelectedEndChromium.png diff --git a/WebKit/chromium/src/js/Images/statusbarBackgroundChromium.png b/WebKit/chromium/src/js/Images/statusbarBackgroundChromium.png Binary files differnew file mode 100755 index 0000000..9d326ac --- /dev/null +++ b/WebKit/chromium/src/js/Images/statusbarBackgroundChromium.png diff --git a/WebKit/chromium/src/js/Images/statusbarBottomBackgroundChromium.png b/WebKit/chromium/src/js/Images/statusbarBottomBackgroundChromium.png Binary files differnew file mode 100755 index 0000000..7c7db0a --- /dev/null +++ b/WebKit/chromium/src/js/Images/statusbarBottomBackgroundChromium.png diff --git a/WebKit/chromium/src/js/Images/statusbarButtonsChromium.png b/WebKit/chromium/src/js/Images/statusbarButtonsChromium.png Binary files differnew file mode 100755 index 0000000..0c6635d --- /dev/null +++ b/WebKit/chromium/src/js/Images/statusbarButtonsChromium.png diff --git a/WebKit/chromium/src/js/Images/statusbarMenuButtonChromium.png b/WebKit/chromium/src/js/Images/statusbarMenuButtonChromium.png Binary files differnew file mode 100755 index 0000000..bf26684 --- /dev/null +++ b/WebKit/chromium/src/js/Images/statusbarMenuButtonChromium.png diff --git a/WebKit/chromium/src/js/Images/statusbarMenuButtonSelectedChromium.png b/WebKit/chromium/src/js/Images/statusbarMenuButtonSelectedChromium.png Binary files differnew file mode 100755 index 0000000..3c0aeec --- /dev/null +++ b/WebKit/chromium/src/js/Images/statusbarMenuButtonSelectedChromium.png diff --git a/WebKit/chromium/src/js/InjectDispatch.js b/WebKit/chromium/src/js/InjectDispatch.js new file mode 100644 index 0000000..e070c42 --- /dev/null +++ b/WebKit/chromium/src/js/InjectDispatch.js @@ -0,0 +1,106 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** + * @fileoverview Injects "injected" object into the inspectable page. + */ + + +var InspectorControllerDispatcher = {}; + +/** + * Main dispatch method, all calls from the host to InspectorController go + * through this one. + * @param {string} functionName Function to call + * @param {string} json_args JSON-serialized call parameters. + * @return {string} JSON-serialized result of the dispatched call. + */ +InspectorControllerDispatcher.dispatch = function(functionName, json_args) +{ + var params = JSON.parse(json_args); + InspectorBackend[functionName].apply(InspectorBackend, params); +}; + +/** + * Special controller object for APU related messages. Outgoing messages + * are sent to this object if the ApuAgentDispatcher is enabled. + **/ +var ApuAgentDispatcher = { enabled : false }; + +/** + * Dispatches messages to APU. This filters and transforms + * outgoing messages that are used by APU. + * @param {string} method name of the dispatch method. + **/ +ApuAgentDispatcher.dispatchToApu = function(method, args) +{ + if (method !== "addRecordToTimeline" && method !== "updateResource" && method !== "addResource") + return; + // TODO(knorton): Transform args so they can be used + // by APU. + DevToolsAgentHost.dispatchToApu(JSON.stringify(args)); +}; + +/** + * This is called by the InspectorFrontend for serialization. + * We serialize the call and send it to the client over the IPC + * using dispatchOut bound method. + */ +function dispatch(method, var_args) { + // Handle all messages with non-primitieve arguments here. + var args = Array.prototype.slice.call(arguments); + + if (method === "inspectedWindowCleared" || method === "reset" || method === "setAttachedWindow") { + // Filter out messages we don't need here. + // We do it on the sender side since they may have non-serializable + // parameters. + return; + } + + // Sniff some inspector controller state changes in order to support + // cross-navigation instrumentation. Keep names in sync with + // webdevtoolsagent_impl. + if (method === "timelineProfilerWasStarted") + DevToolsAgentHost.runtimeFeatureStateChanged("timeline-profiler", true); + else if (method === "timelineProfilerWasStopped") + DevToolsAgentHost.runtimeFeatureStateChanged("timeline-profiler", false); + else if (method === "resourceTrackingWasEnabled") + DevToolsAgentHost.runtimeFeatureStateChanged("resource-tracking", true); + else if (method === "resourceTrackingWasDisabled") + DevToolsAgentHost.runtimeFeatureStateChanged("resource-tracking", false); + + if (ApuAgentDispatcher.enabled) { + ApuAgentDispatcher.dispatchToApu(method, args); + return; + } + + var call = JSON.stringify(args); + DevToolsAgentHost.dispatch(call); +}; diff --git a/WebKit/chromium/src/js/InspectorControllerImpl.js b/WebKit/chromium/src/js/InspectorControllerImpl.js new file mode 100644 index 0000000..c92a94c --- /dev/null +++ b/WebKit/chromium/src/js/InspectorControllerImpl.js @@ -0,0 +1,279 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** + * @fileoverview DevTools' implementation of the InspectorController API. + */ + +if (!this.devtools) + devtools = {}; + +devtools.InspectorBackendImpl = function() +{ + WebInspector.InspectorBackendStub.call(this); + this.installInspectorControllerDelegate_("clearMessages"); + this.installInspectorControllerDelegate_("copyNode"); + this.installInspectorControllerDelegate_("deleteCookie"); + this.installInspectorControllerDelegate_("didEvaluateForTestInFrontend"); + this.installInspectorControllerDelegate_("disableResourceTracking"); + this.installInspectorControllerDelegate_("disableTimeline"); + this.installInspectorControllerDelegate_("enableResourceTracking"); + this.installInspectorControllerDelegate_("enableTimeline"); + this.installInspectorControllerDelegate_("getChildNodes"); + this.installInspectorControllerDelegate_("getCookies"); + this.installInspectorControllerDelegate_("getDatabaseTableNames"); + this.installInspectorControllerDelegate_("getDOMStorageEntries"); + this.installInspectorControllerDelegate_("getEventListenersForNode"); + this.installInspectorControllerDelegate_("getResourceContent"); + this.installInspectorControllerDelegate_("highlightDOMNode"); + this.installInspectorControllerDelegate_("hideDOMNodeHighlight"); + this.installInspectorControllerDelegate_("releaseWrapperObjectGroup"); + this.installInspectorControllerDelegate_("removeAttribute"); + this.installInspectorControllerDelegate_("removeDOMStorageItem"); + this.installInspectorControllerDelegate_("removeNode"); + this.installInspectorControllerDelegate_("saveFrontendSettings"); + this.installInspectorControllerDelegate_("setAttribute"); + this.installInspectorControllerDelegate_("setDOMStorageItem"); + this.installInspectorControllerDelegate_("setInjectedScriptSource"); + this.installInspectorControllerDelegate_("setTextNodeValue"); + this.installInspectorControllerDelegate_("startTimelineProfiler"); + this.installInspectorControllerDelegate_("stopTimelineProfiler"); + this.installInspectorControllerDelegate_("storeLastActivePanel"); +}; +devtools.InspectorBackendImpl.prototype.__proto__ = WebInspector.InspectorBackendStub.prototype; + + +/** + * {@inheritDoc}. + */ +devtools.InspectorBackendImpl.prototype.toggleNodeSearch = function() +{ + WebInspector.InspectorBackendStub.prototype.toggleNodeSearch.call(this); + this.callInspectorController_.call(this, "toggleNodeSearch"); + if (!this.searchingForNode()) { + // This is called from ElementsPanel treeOutline's focusNodeChanged(). + DevToolsHost.activateWindow(); + } +}; + + +/** + * @override + */ +devtools.InspectorBackendImpl.prototype.debuggerEnabled = function() +{ + return true; +}; + + +/** + * @override + */ +devtools.InspectorBackendImpl.prototype.profilerEnabled = function() +{ + return true; +}; + + +devtools.InspectorBackendImpl.prototype.addBreakpoint = function(sourceID, line, condition) +{ + devtools.tools.getDebuggerAgent().addBreakpoint(sourceID, line, condition); +}; + + +devtools.InspectorBackendImpl.prototype.removeBreakpoint = function(sourceID, line) +{ + devtools.tools.getDebuggerAgent().removeBreakpoint(sourceID, line); +}; + +devtools.InspectorBackendImpl.prototype.updateBreakpoint = function(sourceID, line, condition) +{ + devtools.tools.getDebuggerAgent().updateBreakpoint(sourceID, line, condition); +}; + +devtools.InspectorBackendImpl.prototype.pauseInDebugger = function() +{ + devtools.tools.getDebuggerAgent().pauseExecution(); +}; + + +devtools.InspectorBackendImpl.prototype.resumeDebugger = function() +{ + devtools.tools.getDebuggerAgent().resumeExecution(); +}; + + +devtools.InspectorBackendImpl.prototype.stepIntoStatementInDebugger = function() +{ + devtools.tools.getDebuggerAgent().stepIntoStatement(); +}; + + +devtools.InspectorBackendImpl.prototype.stepOutOfFunctionInDebugger = function() +{ + devtools.tools.getDebuggerAgent().stepOutOfFunction(); +}; + + +devtools.InspectorBackendImpl.prototype.stepOverStatementInDebugger = function() +{ + devtools.tools.getDebuggerAgent().stepOverStatement(); +}; + +/** + * @override + */ +devtools.InspectorBackendImpl.prototype.setPauseOnExceptionsState = function(state) +{ + this._setPauseOnExceptionsState = state; + // TODO(yurys): support all three states. See http://crbug.com/32877 + var enabled = (state !== WebInspector.ScriptsPanel.PauseOnExceptionsState.DontPauseOnExceptions); + return devtools.tools.getDebuggerAgent().setPauseOnExceptions(enabled); +}; + +/** + * @override + */ +devtools.InspectorBackendImpl.prototype.pauseOnExceptionsState = function() +{ + return (this._setPauseOnExceptionsState || WebInspector.ScriptsPanel.PauseOnExceptionsState.DontPauseOnExceptions); +}; + +/** + * @override + */ +devtools.InspectorBackendImpl.prototype.pauseOnExceptions = function() +{ + return devtools.tools.getDebuggerAgent().pauseOnExceptions(); +}; + + +/** + * @override + */ +devtools.InspectorBackendImpl.prototype.setPauseOnExceptions = function(value) +{ + return devtools.tools.getDebuggerAgent().setPauseOnExceptions(value); +}; + + +/** + * @override + */ +devtools.InspectorBackendImpl.prototype.startProfiling = function() +{ + devtools.tools.getProfilerAgent().startProfiling(devtools.ProfilerAgent.ProfilerModules.PROFILER_MODULE_CPU); +}; + + +/** + * @override + */ +devtools.InspectorBackendImpl.prototype.stopProfiling = function() +{ + devtools.tools.getProfilerAgent().stopProfiling( devtools.ProfilerAgent.ProfilerModules.PROFILER_MODULE_CPU); +}; + + +/** + * @override + */ +devtools.InspectorBackendImpl.prototype.getProfileHeaders = function(callId) +{ + WebInspector.didGetProfileHeaders(callId, []); +}; + + +/** + * Emulate WebKit InspectorController behavior. It stores profiles on renderer side, + * and is able to retrieve them by uid using "getProfile". + */ +devtools.InspectorBackendImpl.prototype.addFullProfile = function(profile) +{ + WebInspector.__fullProfiles = WebInspector.__fullProfiles || {}; + WebInspector.__fullProfiles[profile.uid] = profile; +}; + + +/** + * @override + */ +devtools.InspectorBackendImpl.prototype.getProfile = function(callId, uid) +{ + if (WebInspector.__fullProfiles && (uid in WebInspector.__fullProfiles)) + WebInspector.didGetProfile(callId, WebInspector.__fullProfiles[uid]); +}; + + +/** + * @override + */ +devtools.InspectorBackendImpl.prototype.takeHeapSnapshot = function() +{ + devtools.tools.getProfilerAgent().startProfiling(devtools.ProfilerAgent.ProfilerModules.PROFILER_MODULE_HEAP_SNAPSHOT + | devtools.ProfilerAgent.ProfilerModules.PROFILER_MODULE_HEAP_STATS + | devtools.ProfilerAgent.ProfilerModules.PROFILER_MODULE_JS_CONSTRUCTORS); +}; + + +/** + * @override + */ +devtools.InspectorBackendImpl.prototype.dispatchOnInjectedScript = function(callId, injectedScriptId, methodName, argsString, async) +{ + // Encode injectedScriptId into callId + if (typeof injectedScriptId !== "number") + injectedScriptId = 0; + RemoteToolsAgent.dispatchOnInjectedScript(callId, injectedScriptId, methodName, argsString, async); +}; + + +/** + * Installs delegating handler into the inspector controller. + * @param {string} methodName Method to install delegating handler for. + */ +devtools.InspectorBackendImpl.prototype.installInspectorControllerDelegate_ = function(methodName) +{ + this[methodName] = this.callInspectorController_.bind(this, methodName); +}; + + +/** + * Bound function with the installInjectedScriptDelegate_ actual + * implementation. + */ +devtools.InspectorBackendImpl.prototype.callInspectorController_ = function(methodName, var_arg) +{ + var args = Array.prototype.slice.call(arguments, 1); + RemoteToolsAgent.dispatchOnInspectorController(WebInspector.Callback.wrap(function(){}), methodName, JSON.stringify(args)); +}; + + +InspectorBackend = new devtools.InspectorBackendImpl(); diff --git a/WebKit/chromium/src/js/ProfilerAgent.js b/WebKit/chromium/src/js/ProfilerAgent.js new file mode 100644 index 0000000..e08c5d2 --- /dev/null +++ b/WebKit/chromium/src/js/ProfilerAgent.js @@ -0,0 +1,227 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** + * @fileoverview Provides communication interface to remote v8 profiler. + */ + +/** + * @constructor + */ +devtools.ProfilerAgent = function() +{ + RemoteProfilerAgent.didGetActiveProfilerModules = this._didGetActiveProfilerModules.bind(this); + RemoteProfilerAgent.didGetLogLines = this._didGetLogLines.bind(this); + + /** + * Active profiler modules flags. + * @type {number} + */ + this._activeProfilerModules = devtools.ProfilerAgent.ProfilerModules.PROFILER_MODULE_NONE; + + /** + * Interval for polling profiler state. + * @type {number} + */ + this._getActiveProfilerModulesInterval = null; + + /** + * Profiler log position. + * @type {number} + */ + this._logPosition = 0; + + /** + * Last requested log position. + * @type {number} + */ + this._lastRequestedLogPosition = -1; + + /** + * Whether log contents retrieval must be forced next time. + * @type {boolean} + */ + this._forceGetLogLines = false; + + /** + * Profiler processor instance. + * @type {devtools.profiler.Processor} + */ + this._profilerProcessor = new devtools.profiler.Processor(); +}; + + +/** + * A copy of enum from include/v8.h + * @enum {number} + */ +devtools.ProfilerAgent.ProfilerModules = { + PROFILER_MODULE_NONE: 0, + PROFILER_MODULE_CPU: 1, + PROFILER_MODULE_HEAP_STATS: 1 << 1, + PROFILER_MODULE_JS_CONSTRUCTORS: 1 << 2, + PROFILER_MODULE_HEAP_SNAPSHOT: 1 << 16 +}; + + +/** + * Sets up callbacks that deal with profiles processing. + */ +devtools.ProfilerAgent.prototype.setupProfilerProcessorCallbacks = function() +{ + // A temporary icon indicating that the profile is being processed. + var processingIcon = new WebInspector.SidebarTreeElement( + "profile-sidebar-tree-item", + WebInspector.UIString("Processing..."), + '', null, false); + var profilesSidebar = WebInspector.panels.profiles.getProfileType(WebInspector.CPUProfileType.TypeId).treeElement; + + this._profilerProcessor.setCallbacks( + function onProfileProcessingStarted() { + // Set visually empty string. Subtitle hiding is done via styles + // manipulation which doesn't play well with dynamic append / removal. + processingIcon.subtitle = " "; + profilesSidebar.appendChild(processingIcon); + }, + function onProfileProcessingStatus(ticksCount) { + processingIcon.subtitle = WebInspector.UIString("%d ticks processed", ticksCount); + }, + function onProfileProcessingFinished(profile) { + profilesSidebar.removeChild(processingIcon); + profile.typeId = WebInspector.CPUProfileType.TypeId; + InspectorBackend.addFullProfile(profile); + WebInspector.addProfileHeader(profile); + // If no profile is currently shown, show the new one. + var profilesPanel = WebInspector.panels.profiles; + if (!profilesPanel.visibleView) { + profilesPanel.showProfile(profile); + } + } + ); +}; + + +/** + * Initializes profiling state. + */ +devtools.ProfilerAgent.prototype.initializeProfiling = function() +{ + this.setupProfilerProcessorCallbacks(); + this._forceGetLogLines = true; + this._getActiveProfilerModulesInterval = setInterval(function() { RemoteProfilerAgent.getActiveProfilerModules(); }, 1000); +}; + + +/** + * Requests the next chunk of log lines. + * @param {boolean} immediately Do not postpone the request. + * @private + */ +devtools.ProfilerAgent.prototype._getNextLogLines = function(immediately) +{ + if (this._lastRequestedLogPosition == this._logPosition) + return; + var pos = this._lastRequestedLogPosition = this._logPosition; + if (immediately) + RemoteProfilerAgent.getLogLines(pos); + else + setTimeout(function() { RemoteProfilerAgent.getLogLines(pos); }, 500); +}; + + +/** + * Starts profiling. + * @param {number} modules List of modules to enable. + */ +devtools.ProfilerAgent.prototype.startProfiling = function(modules) +{ + var cmd = new devtools.DebugCommand("profile", { + "modules": modules, + "command": "resume"}); + devtools.DebuggerAgent.sendCommand_(cmd); + RemoteDebuggerAgent.processDebugCommands(); + if (modules & devtools.ProfilerAgent.ProfilerModules.PROFILER_MODULE_HEAP_SNAPSHOT) { + // Active modules will not change, instead, a snapshot will be logged. + this._getNextLogLines(); + } +}; + + +/** + * Stops profiling. + */ +devtools.ProfilerAgent.prototype.stopProfiling = function(modules) +{ + var cmd = new devtools.DebugCommand("profile", { + "modules": modules, + "command": "pause"}); + devtools.DebuggerAgent.sendCommand_(cmd); + RemoteDebuggerAgent.processDebugCommands(); +}; + + +/** + * Handles current profiler status. + * @param {number} modules List of active (started) modules. + */ +devtools.ProfilerAgent.prototype._didGetActiveProfilerModules = function(modules) +{ + var profModules = devtools.ProfilerAgent.ProfilerModules; + var profModuleNone = profModules.PROFILER_MODULE_NONE; + if (this._forceGetLogLines || (modules !== profModuleNone && this._activeProfilerModules === profModuleNone)) { + this._forceGetLogLines = false; + // Start to query log data. + this._getNextLogLines(true); + } + this._activeProfilerModules = modules; + // Update buttons. + WebInspector.setRecordingProfile(modules & profModules.PROFILER_MODULE_CPU); +}; + + +/** + * Handles a portion of a profiler log retrieved by getLogLines call. + * @param {number} pos Current position in log. + * @param {string} log A portion of profiler log. + */ +devtools.ProfilerAgent.prototype._didGetLogLines = function(pos, log) +{ + this._logPosition = pos; + if (log.length > 0) + this._profilerProcessor.processLogChunk(log); + else { + // Allow re-reading from the last position. + this._lastRequestedLogPosition = this._logPosition - 1; + if (this._activeProfilerModules === devtools.ProfilerAgent.ProfilerModules.PROFILER_MODULE_NONE) + // No new data and profiling is stopped---suspend log reading. + return; + } + this._getNextLogLines(); +}; diff --git a/WebKit/chromium/src/js/ProfilerProcessor.js b/WebKit/chromium/src/js/ProfilerProcessor.js new file mode 100644 index 0000000..f678d2c --- /dev/null +++ b/WebKit/chromium/src/js/ProfilerProcessor.js @@ -0,0 +1,543 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** + * @fileoverview Profiler processor is used to process log file produced + * by V8 and produce an internal profile representation which is used + * for building profile views in "Profiles" tab. + */ + + +/** + * Creates a Profile View builder object compatible with WebKit Profiler UI. + * + * @param {number} samplingRate Number of ms between profiler ticks. + * @constructor + */ +devtools.profiler.WebKitViewBuilder = function(samplingRate) +{ + devtools.profiler.ViewBuilder.call(this, samplingRate); +}; +devtools.profiler.WebKitViewBuilder.prototype.__proto__ = devtools.profiler.ViewBuilder.prototype; + + +/** + * @override + */ +devtools.profiler.WebKitViewBuilder.prototype.createViewNode = function(funcName, totalTime, selfTime, head) +{ + return new devtools.profiler.WebKitViewNode(funcName, totalTime, selfTime, head); +}; + + +/** + * Constructs a Profile View node object for displaying in WebKit Profiler UI. + * + * @param {string} internalFuncName A fully qualified function name. + * @param {number} totalTime Amount of time that application spent in the + * corresponding function and its descendants (not that depending on + * profile they can be either callees or callers.) + * @param {number} selfTime Amount of time that application spent in the + * corresponding function only. + * @param {devtools.profiler.ProfileView.Node} head Profile view head. + * @constructor + */ +devtools.profiler.WebKitViewNode = function(internalFuncName, totalTime, selfTime, head) +{ + devtools.profiler.ProfileView.Node.call(this, internalFuncName, totalTime, selfTime, head); + this.initFuncInfo_(); + this.callUID = internalFuncName; +}; +devtools.profiler.WebKitViewNode.prototype.__proto__ = devtools.profiler.ProfileView.Node.prototype; + + +/** + * RegEx for stripping V8's prefixes of compiled functions. + */ +devtools.profiler.WebKitViewNode.FUNC_NAME_STRIP_RE = /^(?:LazyCompile|Function|Callback): (.*)$/; + + +/** + * RegEx for extracting script source URL and line number. + */ +devtools.profiler.WebKitViewNode.FUNC_NAME_PARSE_RE = /^((?:get | set )?[^ ]+) (.*):(\d+)( \{\d+\})?$/; + + +/** + * Inits "functionName", "url", and "lineNumber" fields using "internalFuncName" + * field. + * @private + */ +devtools.profiler.WebKitViewNode.prototype.initFuncInfo_ = function() +{ + var nodeAlias = devtools.profiler.WebKitViewNode; + this.functionName = this.internalFuncName; + + var strippedName = nodeAlias.FUNC_NAME_STRIP_RE.exec(this.functionName); + if (strippedName) + this.functionName = strippedName[1]; + + var parsedName = nodeAlias.FUNC_NAME_PARSE_RE.exec(this.functionName); + if (parsedName) { + this.functionName = parsedName[1]; + if (parsedName[4]) + this.functionName += parsedName[4]; + this.url = parsedName[2]; + this.lineNumber = parsedName[3]; + } else { + this.url = ''; + this.lineNumber = 0; + } +}; + + +/** + * Ancestor of a profile object that leaves out only JS-related functions. + * @constructor + */ +devtools.profiler.JsProfile = function() +{ + devtools.profiler.Profile.call(this); +}; +devtools.profiler.JsProfile.prototype.__proto__ = devtools.profiler.Profile.prototype; + + +/** + * RegExp that leaves only non-native JS functions. + * @type {RegExp} + */ +devtools.profiler.JsProfile.JS_NON_NATIVE_RE = new RegExp( + "^" + + "(?:Callback:)|" + + "(?:Script: (?!native))|" + + "(?:(?:LazyCompile|Function): [^ ]*(?: (?!native )[^ ]+:\\d+)?$)"); + + +/** + * @override + */ +devtools.profiler.JsProfile.prototype.skipThisFunction = function(name) +{ + return !devtools.profiler.JsProfile.JS_NON_NATIVE_RE.test(name); +}; + + +/** + * Profiler processor. Consumes profiler log and builds profile views. + * FIXME: change field naming style to use trailing underscore. + * + * @param {function(devtools.profiler.ProfileView)} newProfileCallback Callback + * that receives a new processed profile. + * @constructor + */ +devtools.profiler.Processor = function() +{ + var dispatches = { + "code-creation": { + parsers: [null, this.createAddressParser("code"), parseInt, null], + processor: this.processCodeCreation_, backrefs: true, + needsProfile: true }, + "code-move": { parsers: [this.createAddressParser("code"), + this.createAddressParser("code-move-to")], + processor: this.processCodeMove_, backrefs: true, + needsProfile: true }, + "code-delete": { parsers: [this.createAddressParser("code")], + processor: this.processCodeDelete_, backrefs: true, + needsProfile: true }, + "function-creation": { parsers: [this.createAddressParser("code"), + this.createAddressParser("function-obj")], + processor: this.processFunctionCreation_, backrefs: true }, + "function-move": { parsers: [this.createAddressParser("code"), + this.createAddressParser("code-move-to")], + processor: this.processFunctionMove_, backrefs: true }, + "function-delete": { parsers: [this.createAddressParser("code")], + processor: this.processFunctionDelete_, backrefs: true }, + "tick": { parsers: [this.createAddressParser("code"), + this.createAddressParser("stack"), parseInt, "var-args"], + processor: this.processTick_, backrefs: true, needProfile: true }, + "profiler": { parsers: [null, "var-args"], + processor: this.processProfiler_, needsProfile: false }, + "heap-sample-begin": { parsers: [null, null, parseInt], + processor: this.processHeapSampleBegin_ }, + "heap-sample-stats": { parsers: [null, null, parseInt, parseInt], + processor: this.processHeapSampleStats_ }, + "heap-sample-item": { parsers: [null, parseInt, parseInt], + processor: this.processHeapSampleItem_ }, + "heap-js-cons-item": { parsers: [null, parseInt, parseInt], + processor: this.processHeapJsConsItem_ }, + "heap-js-ret-item": { parsers: [null, "var-args"], + processor: this.processHeapJsRetItem_ }, + "heap-sample-end": { parsers: [null, null], + processor: this.processHeapSampleEnd_ }, + // Not used in DevTools Profiler. + "shared-library": null, + // Obsolete row types. + "code-allocate": null, + "begin-code-region": null, + "end-code-region": null}; + + if (devtools.profiler.Profile.VERSION === 2) { + dispatches["tick"] = { parsers: [this.createAddressParser("code"), + this.createAddressParser("stack"), + this.createAddressParser("func"), parseInt, "var-args"], + processor: this.processTickV2_, backrefs: true }; + } + + devtools.profiler.LogReader.call(this, dispatches); + + /** + * Callback that is called when a new profile is encountered in the log. + * @type {function()} + */ + this.startedProfileProcessing_ = null; + + /** + * Callback that is called periodically to display processing status. + * @type {function()} + */ + this.profileProcessingStatus_ = null; + + /** + * Callback that is called when a profile has been processed and is ready + * to be shown. + * @type {function(devtools.profiler.ProfileView)} + */ + this.finishedProfileProcessing_ = null; + + /** + * The current profile. + * @type {devtools.profiler.JsProfile} + */ + this.currentProfile_ = null; + + /** + * Builder of profile views. Created during "profiler,begin" event processing. + * @type {devtools.profiler.WebKitViewBuilder} + */ + this.viewBuilder_ = null; + + /** + * Next profile id. + * @type {number} + */ + this.profileId_ = 1; + + /** + * Counter for processed ticks. + * @type {number} + */ + this.ticksCount_ = 0; + + /** + * Interval id for updating processing status. + * @type {number} + */ + this.processingInterval_ = null; + + /** + * The current heap snapshot. + * @type {string} + */ + this.currentHeapSnapshot_ = null; + + /** + * Next heap snapshot id. + * @type {number} + */ + this.heapSnapshotId_ = 1; +}; +devtools.profiler.Processor.prototype.__proto__ = devtools.profiler.LogReader.prototype; + + +/** + * @override + */ +devtools.profiler.Processor.prototype.printError = function(str) +{ + debugPrint(str); +}; + + +/** + * @override + */ +devtools.profiler.Processor.prototype.skipDispatch = function(dispatch) +{ + return dispatch.needsProfile && this.currentProfile_ === null; +}; + + +/** + * Sets profile processing callbacks. + * + * @param {function()} started Started processing callback. + * @param {function(devtools.profiler.ProfileView)} finished Finished + * processing callback. + */ +devtools.profiler.Processor.prototype.setCallbacks = function(started, processing, finished) +{ + this.startedProfileProcessing_ = started; + this.profileProcessingStatus_ = processing; + this.finishedProfileProcessing_ = finished; +}; + + +/** + * An address for the fake "(program)" entry. WebKit's visualisation + * has assumptions on how the top of the call tree should look like, + * and we need to add a fake entry as the topmost function. This + * address is chosen because it's the end address of the first memory + * page, which is never used for code or data, but only as a guard + * page for catching AV errors. + * + * @type {number} + */ +devtools.profiler.Processor.PROGRAM_ENTRY = 0xffff; +/** + * @type {string} + */ +devtools.profiler.Processor.PROGRAM_ENTRY_STR = "0xffff"; + + +/** + * Sets new profile callback. + * @param {function(devtools.profiler.ProfileView)} callback Callback function. + */ +devtools.profiler.Processor.prototype.setNewProfileCallback = function(callback) +{ + this.newProfileCallback_ = callback; +}; + + +devtools.profiler.Processor.prototype.processProfiler_ = function(state, params) +{ + switch (state) { + case "resume": + if (this.currentProfile_ === null) { + this.currentProfile_ = new devtools.profiler.JsProfile(); + // see the comment for devtools.profiler.Processor.PROGRAM_ENTRY + this.currentProfile_.addCode("Function", "(program)", devtools.profiler.Processor.PROGRAM_ENTRY, 1); + if (this.startedProfileProcessing_) + this.startedProfileProcessing_(); + this.ticksCount_ = 0; + var self = this; + if (this.profileProcessingStatus_) { + this.processingInterval_ = window.setInterval( + function() { self.profileProcessingStatus_(self.ticksCount_); }, + 1000); + } + } + break; + case "pause": + if (this.currentProfile_ !== null) { + window.clearInterval(this.processingInterval_); + this.processingInterval_ = null; + if (this.finishedProfileProcessing_) + this.finishedProfileProcessing_(this.createProfileForView()); + this.currentProfile_ = null; + } + break; + case "begin": + var samplingRate = NaN; + if (params.length > 0) + samplingRate = parseInt(params[0]); + if (isNaN(samplingRate)) + samplingRate = 1; + this.viewBuilder_ = new devtools.profiler.WebKitViewBuilder(samplingRate); + break; + // These events are valid but aren't used. + case "compression": + case "end": break; + default: + throw new Error("unknown profiler state: " + state); + } +}; + + +devtools.profiler.Processor.prototype.processCodeCreation_ = function(type, start, size, name) +{ + this.currentProfile_.addCode(this.expandAlias(type), name, start, size); +}; + + +devtools.profiler.Processor.prototype.processCodeMove_ = function(from, to) +{ + this.currentProfile_.moveCode(from, to); +}; + + +devtools.profiler.Processor.prototype.processCodeDelete_ = function(start) +{ + this.currentProfile_.deleteCode(start); +}; + + +devtools.profiler.Processor.prototype.processFunctionCreation_ = function(functionAddr, codeAddr) +{ + this.currentProfile_.addCodeAlias(functionAddr, codeAddr); +}; + + +devtools.profiler.Processor.prototype.processFunctionMove_ = function(from, to) +{ + this.currentProfile_.safeMoveDynamicCode(from, to); +}; + + +devtools.profiler.Processor.prototype.processFunctionDelete_ = function(start) +{ + this.currentProfile_.safeDeleteDynamicCode(start); +}; + + +// TODO(mnaganov): Remove after next V8 roll. +devtools.profiler.Processor.prototype.processTick_ = function(pc, sp, vmState, stack) +{ + // see the comment for devtools.profiler.Processor.PROGRAM_ENTRY + stack.push(devtools.profiler.Processor.PROGRAM_ENTRY_STR); + this.currentProfile_.recordTick(this.processStack(pc, stack)); + this.ticksCount_++; +}; + + +devtools.profiler.Processor.prototype.processTickV2_ = function(pc, sp, func, vmState, stack) +{ + // see the comment for devtools.profiler.Processor.PROGRAM_ENTRY + stack.push(devtools.profiler.Processor.PROGRAM_ENTRY_STR); + + + if (func) { + var funcEntry = this.currentProfile_.findEntry(func); + if (!funcEntry || !funcEntry.isJSFunction || !funcEntry.isJSFunction()) + func = 0; + else { + var currEntry = this.currentProfile_.findEntry(pc); + if (!currEntry || !currEntry.isJSFunction || currEntry.isJSFunction()) { + func = 0; + } + } + } + + this.currentProfile_.recordTick(this.processStack(pc, func, stack)); + this.ticksCount_++; +}; + + +devtools.profiler.Processor.prototype.processHeapSampleBegin_ = function(space, state, ticks) +{ + if (space !== "Heap") return; + this.currentHeapSnapshot_ = { + number: this.heapSnapshotId_++, + entries: {}, + clusters: {}, + lowlevels: {}, + ticks: ticks + }; +}; + + +devtools.profiler.Processor.prototype.processHeapSampleStats_ = function(space, state, capacity, used) +{ + if (space !== "Heap") return; +}; + + +devtools.profiler.Processor.prototype.processHeapSampleItem_ = function(item, number, size) +{ + if (!this.currentHeapSnapshot_) return; + this.currentHeapSnapshot_.lowlevels[item] = { + type: item, count: number, size: size + }; +}; + + +devtools.profiler.Processor.prototype.processHeapJsConsItem_ = function(item, number, size) +{ + if (!this.currentHeapSnapshot_) return; + this.currentHeapSnapshot_.entries[item] = { + cons: item, count: number, size: size, retainers: {} + }; +}; + + +devtools.profiler.Processor.prototype.processHeapJsRetItem_ = function(item, retainersArray) +{ + if (!this.currentHeapSnapshot_) return; + var rawRetainers = {}; + for (var i = 0, n = retainersArray.length; i < n; ++i) { + var entry = retainersArray[i].split(";"); + rawRetainers[entry[0]] = parseInt(entry[1], 10); + } + + function mergeRetainers(entry) { + for (var rawRetainer in rawRetainers) { + var consName = rawRetainer.indexOf(":") !== -1 ? rawRetainer.split(":")[0] : rawRetainer; + if (!(consName in entry.retainers)) + entry.retainers[consName] = { cons: consName, count: 0, clusters: {} }; + var retainer = entry.retainers[consName]; + retainer.count += rawRetainers[rawRetainer]; + if (consName !== rawRetainer) + retainer.clusters[rawRetainer] = true; + } + } + + if (item.indexOf(":") !== -1) { + // Array, Function, or Object instances cluster case. + if (!(item in this.currentHeapSnapshot_.clusters)) { + this.currentHeapSnapshot_.clusters[item] = { + cons: item, retainers: {} + }; + } + mergeRetainers(this.currentHeapSnapshot_.clusters[item]); + item = item.split(":")[0]; + } + mergeRetainers(this.currentHeapSnapshot_.entries[item]); +}; + + +devtools.profiler.Processor.prototype.processHeapSampleEnd_ = function(space, state) +{ + if (space !== "Heap") return; + var snapshot = this.currentHeapSnapshot_; + this.currentHeapSnapshot_ = null; + WebInspector.panels.profiles.addSnapshot(snapshot); +}; + + +/** + * Creates a profile for further displaying in ProfileView. + */ +devtools.profiler.Processor.prototype.createProfileForView = function() +{ + var profile = this.viewBuilder_.buildView(this.currentProfile_.getTopDownProfile()); + profile.uid = this.profileId_++; + profile.title = UserInitiatedProfileName + "." + profile.uid; + return profile; +}; diff --git a/WebKit/chromium/src/js/Tests.js b/WebKit/chromium/src/js/Tests.js new file mode 100644 index 0000000..fa0c99f --- /dev/null +++ b/WebKit/chromium/src/js/Tests.js @@ -0,0 +1,1862 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + + +/** + * @fileoverview This file contains small testing framework along with the + * test suite for the frontend. These tests are a part of the continues build + * and are executed by the devtools_sanity_unittest.cc as a part of the + * Interactive UI Test suite. + * FIXME: change field naming style to use trailing underscore. + */ + +if (window.domAutomationController) { + +var ___interactiveUiTestsMode = true; + +/** + * Test suite for interactive UI tests. + * @constructor + */ +TestSuite = function() +{ + this.controlTaken_ = false; + this.timerId_ = -1; +}; + + +/** + * Reports test failure. + * @param {string} message Failure description. + */ +TestSuite.prototype.fail = function(message) +{ + if (this.controlTaken_) + this.reportFailure_(message); + else + throw message; +}; + + +/** + * Equals assertion tests that expected === actual. + * @param {Object} expected Expected object. + * @param {Object} actual Actual object. + * @param {string} opt_message User message to print if the test fails. + */ +TestSuite.prototype.assertEquals = function(expected, actual, opt_message) +{ + if (expected !== actual) { + var message = "Expected: '" + expected + "', but was '" + actual + "'"; + if (opt_message) + message = opt_message + "(" + message + ")"; + this.fail(message); + } +}; + + +/** + * True assertion tests that value == true. + * @param {Object} value Actual object. + * @param {string} opt_message User message to print if the test fails. + */ +TestSuite.prototype.assertTrue = function(value, opt_message) +{ + this.assertEquals(true, !!value, opt_message); +}; + + +/** + * Contains assertion tests that string contains substring. + * @param {string} string Outer. + * @param {string} substring Inner. + */ +TestSuite.prototype.assertContains = function(string, substring) +{ + if (string.indexOf(substring) === -1) + this.fail("Expected to: '" + string + "' to contain '" + substring + "'"); +}; + + +/** + * Takes control over execution. + */ +TestSuite.prototype.takeControl = function() +{ + this.controlTaken_ = true; + // Set up guard timer. + var self = this; + this.timerId_ = setTimeout(function() { + self.reportFailure_("Timeout exceeded: 20 sec"); + }, 20000); +}; + + +/** + * Releases control over execution. + */ +TestSuite.prototype.releaseControl = function() +{ + if (this.timerId_ !== -1) { + clearTimeout(this.timerId_); + this.timerId_ = -1; + } + this.reportOk_(); +}; + + +/** + * Async tests use this one to report that they are completed. + */ +TestSuite.prototype.reportOk_ = function() +{ + window.domAutomationController.send("[OK]"); +}; + + +/** + * Async tests use this one to report failures. + */ +TestSuite.prototype.reportFailure_ = function(error) +{ + if (this.timerId_ !== -1) { + clearTimeout(this.timerId_); + this.timerId_ = -1; + } + window.domAutomationController.send("[FAILED] " + error); +}; + + +/** + * Runs all global functions starting with "test" as unit tests. + */ +TestSuite.prototype.runTest = function(testName) +{ + try { + this[testName](); + if (!this.controlTaken_) + this.reportOk_(); + } catch (e) { + this.reportFailure_(e); + } +}; + + +/** + * @param {string} panelName Name of the panel to show. + */ +TestSuite.prototype.showPanel = function(panelName) +{ + // Open Scripts panel. + var toolbar = document.getElementById("toolbar"); + var button = toolbar.getElementsByClassName(panelName)[0]; + button.click(); + this.assertEquals(WebInspector.panels[panelName], WebInspector.currentPanel); +}; + + +/** + * Overrides the method with specified name until it's called first time. + * @param {Object} receiver An object whose method to override. + * @param {string} methodName Name of the method to override. + * @param {Function} override A function that should be called right after the + * overriden method returns. + * @param {boolean} opt_sticky Whether restore original method after first run + * or not. + */ +TestSuite.prototype.addSniffer = function(receiver, methodName, override, opt_sticky) +{ + var orig = receiver[methodName]; + if (typeof orig !== "function") + this.fail("Cannot find method to override: " + methodName); + var test = this; + receiver[methodName] = function(var_args) { + try { + var result = orig.apply(this, arguments); + } finally { + if (!opt_sticky) + receiver[methodName] = orig; + } + // In case of exception the override won't be called. + try { + override.apply(this, arguments); + } catch (e) { + test.fail("Exception in overriden method '" + methodName + "': " + e); + } + return result; + }; +}; + + +// UI Tests + + +/** + * Tests that the real injected host is present in the context. + */ +TestSuite.prototype.testHostIsPresent = function() +{ + this.assertTrue(typeof InspectorFrontendHost === "object" && !InspectorFrontendHost.isStub); +}; + + +/** + * Tests elements tree has an "HTML" root. + */ +TestSuite.prototype.testElementsTreeRoot = function() +{ + var doc = WebInspector.domAgent.document; + this.assertEquals("HTML", doc.documentElement.nodeName); + this.assertTrue(doc.documentElement.hasChildNodes()); +}; + + +/** + * Tests that main resource is present in the system and that it is + * the only resource. + */ +TestSuite.prototype.testMainResource = function() +{ + var tokens = []; + var resources = WebInspector.resources; + for (var id in resources) + tokens.push(resources[id].lastPathComponent); + this.assertEquals("simple_page.html", tokens.join(",")); +}; + + +/** + * Tests that resources tab is enabled when corresponding item is selected. + */ +TestSuite.prototype.testEnableResourcesTab = function() +{ + this.showPanel("resources"); + + var test = this; + this.addSniffer(WebInspector, "updateResource", + function(identifier, payload) { + test.assertEquals("simple_page.html", payload.lastPathComponent); + WebInspector.panels.resources.refresh(); + WebInspector.panels.resources.revealAndSelectItem(WebInspector.resources[identifier]); + + test.releaseControl(); + }); + + // Following call should lead to reload that we capture in the + // addResource override. + WebInspector.panels.resources._enableResourceTracking(); + + // We now have some time to report results to controller. + this.takeControl(); +}; + + +/** + * Tests that correct content length is reported for resources. + */ +TestSuite.prototype.testResourceContentLength = function() +{ + this.showPanel("resources"); + var test = this; + + var png = false; + var html = false; + this.addSniffer(WebInspector, "updateResource", + function(identifier, payload) { + if (!payload.didLengthChange) + return; + var resource = WebInspector.resources[identifier]; + if (!resource || !resource.url) + return; + if (resource.url.search("image.html$") !== -1) { + var expectedLength = 87; + test.assertTrue( + resource.contentLength <= expectedLength, + "image.html content length is greater thatn expected."); + if (expectedLength === resource.contentLength) + html = true; + } else if (resource.url.search("image.png") !== -1) { + var expectedLength = 257796; + test.assertTrue( + resource.contentLength <= expectedLength, + "image.png content length is greater than expected."); + if (expectedLength === resource.contentLength) + png = true; + } + if (html && png) { + // Wait 1 second before releasing control to check that the content + // lengths are not updated anymore. + setTimeout(function() { + test.releaseControl(); + }, 1000); + } + }, true); + + // Make sure resource tracking is on. + WebInspector.panels.resources._enableResourceTracking(); + // Reload inspected page to update all resources. + test.evaluateInConsole_( + "window.location.reload(true);", + function(resultText) { + test.assertEquals("undefined", resultText, "Unexpected result of reload()."); + }); + + // We now have some time to report results to controller. + this.takeControl(); +}; + + +/** + * Tests resource headers. + */ +TestSuite.prototype.testResourceHeaders = function() +{ + this.showPanel("resources"); + + var test = this; + + var responseOk = false; + var timingOk = false; + + this.addSniffer(WebInspector, "updateResource", + function(identifier, payload) { + var resource = this.resources[identifier]; + if (!resource || resource.mainResource) { + // We are only interested in secondary resources in this test. + return; + } + + var requestHeaders = JSON.stringify(resource.requestHeaders); + test.assertContains(requestHeaders, "Accept"); + + if (payload.didResponseChange) { + var responseHeaders = JSON.stringify(resource.responseHeaders); + test.assertContains(responseHeaders, "Content-type"); + test.assertContains(responseHeaders, "Content-Length"); + test.assertTrue(typeof resource.responseReceivedTime !== "undefined"); + responseOk = true; + } + + if (payload.didTimingChange) { + test.assertTrue(typeof resource.startTime !== "undefined"); + timingOk = true; + } + + if (payload.didCompletionChange) { + test.assertTrue(responseOk); + test.assertTrue(timingOk); + test.assertTrue(typeof resource.endTime !== "undefined"); + test.releaseControl(); + } + }, true); + + WebInspector.panels.resources._enableResourceTracking(); + this.takeControl(); +}; + + +/** + * Tests the mime type of a cached (HTTP 304) resource. + */ +TestSuite.prototype.testCachedResourceMimeType = function() +{ + this.showPanel("resources"); + + var test = this; + var hasReloaded = false; + + this.addSniffer(WebInspector, "updateResource", + function(identifier, payload) { + var resource = this.resources[identifier]; + if (!resource || resource.mainResource) { + // We are only interested in secondary resources in this test. + return; + } + + if (payload.didResponseChange) { + // Test server uses a default mime type for JavaScript files. + test.assertEquals("text/html", payload.mimeType); + if (!hasReloaded) { + hasReloaded = true; + // Reload inspected page to update all resources. + test.evaluateInConsole_("window.location.reload(true);", function() {}); + } else + test.releaseControl(); + } + + }, true); + + WebInspector.panels.resources._enableResourceTracking(); + this.takeControl(); +}; + + +/** + * Tests that profiler works. + */ +TestSuite.prototype.testProfilerTab = function() +{ + this.showPanel("profiles"); + + var test = this; + this.addSniffer(WebInspector.panels.profiles, "addProfileHeader", + function(typeOrProfile, profile) { + if (!profile) + profile = typeOrProfile; + var panel = WebInspector.panels.profiles; + panel.showProfile(profile); + var node = panel.visibleView.profileDataGridTree.children[0]; + // Iterate over displayed functions and search for a function + // that is called "fib" or "eternal_fib". If found, it will mean + // that we actually have profiled page's code. + while (node) { + if (node.functionName.indexOf("fib") !== -1) + test.releaseControl(); + node = node.traverseNextNode(true, null, true); + } + + test.fail(); + }); + var ticksCount = 0; + var tickRecord = "\nt,"; + this.addSniffer(RemoteProfilerAgent, "didGetLogLines", + function(posIgnored, log) { + var pos = 0; + while ((pos = log.indexOf(tickRecord, pos)) !== -1) { + pos += tickRecord.length; + ticksCount++; + } + if (ticksCount > 100) + InspectorBackend.stopProfiling(); + }, true); + + InspectorBackend.startProfiling(); + this.takeControl(); +}; + + +/** + * Tests that scripts tab can be open and populated with inspected scripts. + */ +TestSuite.prototype.testShowScriptsTab = function() +{ + this.showPanel("scripts"); + var test = this; + // There should be at least main page script. + this._waitUntilScriptsAreParsed(["debugger_test_page.html$"], + function() { + test.releaseControl(); + }); + // Wait until all scripts are added to the debugger. + this.takeControl(); +}; + + +/** + * Tests that scripts tab is populated with inspected scripts even if it + * hadn't been shown by the moment inspected paged refreshed. + * @see http://crbug.com/26312 + */ +TestSuite.prototype.testScriptsTabIsPopulatedOnInspectedPageRefresh = function() +{ + var test = this; + this.assertEquals(WebInspector.panels.elements, WebInspector.currentPanel, "Elements panel should be current one."); + + this.addSniffer(devtools.DebuggerAgent.prototype, "reset", waitUntilScriptIsParsed); + + // Reload inspected page. It will reset the debugger agent. + test.evaluateInConsole_( + "window.location.reload(true);", + function(resultText) { + test.assertEquals("undefined", resultText, "Unexpected result of reload()."); + }); + + function waitUntilScriptIsParsed() { + var parsed = devtools.tools.getDebuggerAgent().parsedScripts_; + for (var id in parsed) { + var url = parsed[id].getUrl(); + if (url && url.search("debugger_test_page.html$") !== -1) { + checkScriptsPanel(); + return; + } + } + test.addSniffer(devtools.DebuggerAgent.prototype, "addScriptInfo_", waitUntilScriptIsParsed); + } + + function checkScriptsPanel() { + test.showPanel("scripts"); + test.assertTrue(test._scriptsAreParsed(["debugger_test_page.html$"]), "Inspected script not found in the scripts list"); + test.releaseControl(); + } + + // Wait until all scripts are added to the debugger. + this.takeControl(); +}; + + +/** + * Tests that scripts list contains content scripts. + */ +TestSuite.prototype.testContentScriptIsPresent = function() +{ + this.showPanel("scripts"); + var test = this; + + test._waitUntilScriptsAreParsed( + ["page_with_content_script.html$", "simple_content_script.js$"], + function() { + test.releaseControl(); + }); + + // Wait until all scripts are added to the debugger. + this.takeControl(); +}; + + +/** + * Tests that scripts are not duplicaed on Scripts tab switch. + */ +TestSuite.prototype.testNoScriptDuplicatesOnPanelSwitch = function() +{ + var test = this; + + // There should be two scripts: one for the main page and another + // one which is source of console API(see + // InjectedScript._ensureCommandLineAPIInstalled). + var expectedScriptsCount = 2; + var parsedScripts = []; + + this.showPanel("scripts"); + + + function switchToElementsTab() { + test.showPanel("elements"); + setTimeout(switchToScriptsTab, 0); + } + + function switchToScriptsTab() { + test.showPanel("scripts"); + setTimeout(checkScriptsPanel, 0); + } + + function checkScriptsPanel() { + test.assertTrue(!!WebInspector.panels.scripts.visibleView, "No visible script view."); + test.assertTrue(test._scriptsAreParsed(["debugger_test_page.html$"]), "Some scripts are missing."); + checkNoDuplicates(); + test.releaseControl(); + } + + function checkNoDuplicates() { + var scriptSelect = document.getElementById("scripts-files"); + var options = scriptSelect.options; + for (var i = 0; i < options.length; i++) { + var scriptName = options[i].text; + for (var j = i + 1; j < options.length; j++) + test.assertTrue(scriptName !== options[j].text, "Found script duplicates: " + test.optionsToString_(options)); + } + } + + test._waitUntilScriptsAreParsed( + ["debugger_test_page.html$"], + function() { + checkNoDuplicates(); + setTimeout(switchToElementsTab, 0); + }); + + + // Wait until all scripts are added to the debugger. + this.takeControl(); +}; + + +/** + * Tests that a breakpoint can be set. + */ +TestSuite.prototype.testSetBreakpoint = function() +{ + var test = this; + this.showPanel("scripts"); + + var breakpointLine = 12; + + this._waitUntilScriptsAreParsed(["debugger_test_page.html"], + function() { + test.showMainPageScriptSource_( + "debugger_test_page.html", + function(view, url) { + view._addBreakpoint(breakpointLine); + // Force v8 execution. + RemoteDebuggerAgent.processDebugCommands(); + test.waitForSetBreakpointResponse_(url, breakpointLine, + function() { + test.releaseControl(); + }); + }); + }); + + this.takeControl(); +}; + + +/** + * Tests that pause on exception works. + */ +TestSuite.prototype.testPauseOnException = function() +{ + this.showPanel("scripts"); + var test = this; + + // TODO(yurys): remove else branch once the states are supported. + if (WebInspector.ScriptsPanel.PauseOnExceptionsState) { + while (WebInspector.currentPanel.pauseOnExceptionButton.state !== WebInspector.ScriptsPanel.PauseOnExceptionsState.PauseOnUncaughtExceptions) + WebInspector.currentPanel.pauseOnExceptionButton.element.click(); + } else { + // Make sure pause on exceptions is on. + if (!WebInspector.currentPanel.pauseOnExceptionButton.toggled) + WebInspector.currentPanel.pauseOnExceptionButton.element.click(); + } + + this._executeCodeWhenScriptsAreParsed("handleClick()", ["pause_on_exception.html$"]); + + this._waitForScriptPause( + { + functionsOnStack: ["throwAnException", "handleClick", "(anonymous function)"], + lineNumber: 6, + lineText: " return unknown_var;" + }, + function() { + test.releaseControl(); + }); + + this.takeControl(); +}; + + +// Tests that debugger works correctly if pause event occurs when DevTools +// frontend is being loaded. +TestSuite.prototype.testPauseWhenLoadingDevTools = function() +{ + this.showPanel("scripts"); + var test = this; + + var expectations = { + functionsOnStack: ["callDebugger"], + lineNumber: 8, + lineText: " debugger;" + }; + + + // Script execution can already be paused. + if (WebInspector.currentPanel.paused) { + var callFrame = WebInspector.currentPanel.sidebarPanes.callstack.selectedCallFrame; + this.assertEquals(expectations.functionsOnStack[0], callFrame.functionName); + var callbackInvoked = false; + this._checkSourceFrameWhenLoaded(expectations, function() { + callbackInvoked = true; + if (test.controlTaken_) + test.releaseControl(); + }); + if (!callbackInvoked) { + test.takeControl(); + } + return; + } + + this._waitForScriptPause( + { + functionsOnStack: ["callDebugger"], + lineNumber: 8, + lineText: " debugger;" + }, + function() { + test.releaseControl(); + }); + this.takeControl(); +}; + + +// Tests that pressing "Pause" will pause script execution if the script +// is already running. +TestSuite.prototype.testPauseWhenScriptIsRunning = function() +{ + this.showPanel("scripts"); + var test = this; + + test.evaluateInConsole_( + 'setTimeout("handleClick()" , 0)', + function(resultText) { + test.assertTrue(!isNaN(resultText), "Failed to get timer id: " + resultText); + testScriptPauseAfterDelay(); + }); + + // Wait for some time to make sure that inspected page is running the + // infinite loop. + function testScriptPauseAfterDelay() { + setTimeout(testScriptPause, 300); + } + + function testScriptPause() { + // The script should be in infinite loop. Click "Pause" button to + // pause it and wait for the result. + WebInspector.panels.scripts.pauseButton.click(); + + test._waitForScriptPause( + { + functionsOnStack: ["handleClick", "(anonymous function)"], + lineNumber: 5, + lineText: " while(true) {" + }, + function() { + test.releaseControl(); + }); + } + + this.takeControl(); +}; + + +/** + * Serializes options collection to string. + * @param {HTMLOptionsCollection} options + * @return {string} + */ +TestSuite.prototype.optionsToString_ = function(options) +{ + var names = []; + for (var i = 0; i < options.length; i++) + names.push('"' + options[i].text + '"'); + return names.join(","); +}; + + +/** + * Ensures that main HTML resource is selected in Scripts panel and that its + * source frame is setup. Invokes the callback when the condition is satisfied. + * @param {HTMLOptionsCollection} options + * @param {function(WebInspector.SourceView,string)} callback + */ +TestSuite.prototype.showMainPageScriptSource_ = function(scriptName, callback) +{ + var test = this; + + var scriptSelect = document.getElementById("scripts-files"); + var options = scriptSelect.options; + + test.assertTrue(options.length, "Scripts list is empty"); + + // Select page's script if it's not current option. + var scriptResource; + if (options[scriptSelect.selectedIndex].text === scriptName) + scriptResource = options[scriptSelect.selectedIndex].representedObject; + else { + var pageScriptIndex = -1; + for (var i = 0; i < options.length; i++) { + if (options[i].text === scriptName) { + pageScriptIndex = i; + break; + } + } + test.assertTrue(-1 !== pageScriptIndex, "Script with url " + scriptName + " not found among " + test.optionsToString_(options)); + scriptResource = options[pageScriptIndex].representedObject; + + // Current panel is "Scripts". + WebInspector.currentPanel._showScriptOrResource(scriptResource); + test.assertEquals(pageScriptIndex, scriptSelect.selectedIndex, "Unexpected selected option index."); + } + + test.assertTrue(scriptResource instanceof WebInspector.Resource, + "Unexpected resource class."); + test.assertTrue(!!scriptResource.url, "Resource URL is null."); + test.assertTrue(scriptResource.url.search(scriptName + "$") !== -1, "Main HTML resource should be selected."); + + var scriptsPanel = WebInspector.panels.scripts; + + var view = scriptsPanel.visibleView; + test.assertTrue(view instanceof WebInspector.SourceView); + + if (!view.sourceFrame._loaded) { + test.addSniffer(view, "_sourceFrameSetupFinished", function(event) { + callback(view, scriptResource.url); + }); + } else + callback(view, scriptResource.url); +}; + + +/* + * Evaluates the code in the console as if user typed it manually and invokes + * the callback when the result message is received and added to the console. + * @param {string} code + * @param {function(string)} callback + */ +TestSuite.prototype.evaluateInConsole_ = function(code, callback) +{ + WebInspector.console.visible = true; + WebInspector.console.prompt.text = code; + WebInspector.console.promptElement.dispatchEvent( TestSuite.createKeyEvent("Enter")); + + this.addSniffer(WebInspector.ConsoleView.prototype, "addMessage", + function(commandResult) { + callback(commandResult.toMessageElement().textContent); + }); +}; + + +/* + * Waits for "setbreakpoint" response, checks that corresponding breakpoint + * was successfully set and invokes the callback if it was. + * @param {string} scriptUrl + * @param {number} breakpointLine + * @param {function()} callback + */ +TestSuite.prototype.waitForSetBreakpointResponse_ = function(scriptUrl, breakpointLine, callback) +{ + var test = this; + test.addSniffer( + devtools.DebuggerAgent.prototype, + "handleSetBreakpointResponse_", + function(msg) { + var bps = this.urlToBreakpoints_[scriptUrl]; + test.assertTrue(!!bps, "No breakpoints for line " + breakpointLine); + var line = devtools.DebuggerAgent.webkitToV8LineNumber_(breakpointLine); + test.assertTrue(!!bps[line].getV8Id(), "Breakpoint id was not assigned."); + callback(); + }); +}; + + +/** + * Tests eval on call frame. + */ +TestSuite.prototype.testEvalOnCallFrame = function() +{ + this.showPanel("scripts"); + + var breakpointLine = 16; + + var test = this; + this.addSniffer(devtools.DebuggerAgent.prototype, "handleScriptsResponse_", + function(msg) { + test.showMainPageScriptSource_( + "debugger_test_page.html", + function(view, url) { + view._addBreakpoint(breakpointLine); + // Force v8 execution. + RemoteDebuggerAgent.processDebugCommands(); + test.waitForSetBreakpointResponse_(url, breakpointLine, setBreakpointCallback); + }); + }); + + function setBreakpointCallback() { + // Since breakpoints are ignored in evals' calculate() function is + // execute after zero-timeout so that the breakpoint is hit. + test.evaluateInConsole_( + 'setTimeout("calculate(123)" , 0)', + function(resultText) { + test.assertTrue(!isNaN(resultText), "Failed to get timer id: " + resultText); + waitForBreakpointHit(); + }); + } + + function waitForBreakpointHit() { + test.addSniffer( + devtools.DebuggerAgent.prototype, + "handleBacktraceResponse_", + function(msg) { + test.assertEquals(2, this.callFrames_.length, "Unexpected stack depth on the breakpoint. " + JSON.stringify(msg)); + test.assertEquals("calculate", this.callFrames_[0].functionName, "Unexpected top frame function."); + // Evaluate "e+1" where "e" is an argument of "calculate" function. + test.evaluateInConsole_( + "e+1", + function(resultText) { + test.assertEquals("124", resultText, 'Unexpected "e+1" value.'); + test.releaseControl(); + }); + }); + } + + this.takeControl(); +}; + + +/** + * Tests that console auto completion works when script execution is paused. + */ +TestSuite.prototype.testCompletionOnPause = function() +{ + this.showPanel("scripts"); + var test = this; + this._executeCodeWhenScriptsAreParsed("handleClick()", ["completion_on_pause.html$"]); + + this._waitForScriptPause( + { + functionsOnStack: ["innerFunction", "handleClick", "(anonymous function)"], + lineNumber: 9, + lineText: " debugger;" + }, + showConsole); + + function showConsole() { + test.addSniffer(WebInspector.console, "afterShow", testLocalsCompletion); + WebInspector.showConsole(); + } + + function testLocalsCompletion() { + checkCompletions("th", ["parameter1", "closureLocal", "p", "createClosureLocal"], testThisCompletion); + } + + function testThisCompletion() { + checkCompletions("this.", ["field1", "field2", "m"], testFieldCompletion); + } + + function testFieldCompletion() { + checkCompletions("this.field1.", ["id", "name"], function() { test.releaseControl(); }); + } + + function checkCompletions(expression, expectedProperties, callback) { + test.addSniffer(WebInspector.console, "_reportCompletions", + function(bestMatchOnly, completionsReadyCallback, dotNotation, bracketNotation, prefix, result, isException) { + test.assertTrue(!isException, "Exception while collecting completions"); + for (var i = 0; i < expectedProperties.length; i++) { + var name = expectedProperties[i]; + test.assertTrue(result[name], "Name " + name + " not found among the completions: " + JSON.stringify(result)); + } + setTimeout(callback, 0); + }); + WebInspector.console.prompt.text = expression; + WebInspector.console.prompt.autoCompleteSoon(); + } + + this.takeControl(); +}; + + +/** + * Tests that inspected page doesn't hang on reload if it contains a syntax + * error and DevTools window is open. + */ +TestSuite.prototype.testAutoContinueOnSyntaxError = function() +{ + this.showPanel("scripts"); + var test = this; + + function checkScriptsList() { + var scriptSelect = document.getElementById("scripts-files"); + var options = scriptSelect.options; + // There should be only console API source (see + // InjectedScript._ensureCommandLineAPIInstalled) since the page script + // contains a syntax error. + for (var i = 0 ; i < options.length; i++) { + if (options[i].text.search("script_syntax_error.html$") !== -1) + test.fail("Script with syntax error should not be in the list of parsed scripts."); + } + } + + this.addSniffer(devtools.DebuggerAgent.prototype, "handleScriptsResponse_", + function(msg) { + checkScriptsList(); + + // Reload inspected page. + test.evaluateInConsole_( + "window.location.reload(true);", + function(resultText) { + test.assertEquals("undefined", resultText, "Unexpected result of reload()."); + waitForExceptionEvent(); + }); + }); + + function waitForExceptionEvent() { + var exceptionCount = 0; + test.addSniffer( + devtools.DebuggerAgent.prototype, + "handleExceptionEvent_", + function(msg) { + exceptionCount++; + test.assertEquals(1, exceptionCount, "Too many exceptions."); + test.assertEquals(undefined, msg.getBody().script, "Unexpected exception: " + JSON.stringify(msg)); + test.releaseControl(); + }); + + // Check that the script is not paused on parse error. + test.addSniffer( + WebInspector, + "pausedScript", + function(callFrames) { + test.fail("Script execution should not pause on syntax error."); + }); + } + + this.takeControl(); +}; + + +/** + * Checks current execution line against expectations. + * @param {WebInspector.SourceFrame} sourceFrame + * @param {number} lineNumber Expected line number + * @param {string} lineContent Expected line text + */ +TestSuite.prototype._checkExecutionLine = function(sourceFrame, lineNumber, lineContent) +{ + this.assertEquals(lineNumber, sourceFrame.executionLine, "Unexpected execution line number."); + this.assertEquals(lineContent, sourceFrame._textModel.line(lineNumber - 1), "Unexpected execution line text."); +} + + +/** + * Checks that all expected scripts are present in the scripts list + * in the Scripts panel. + * @param {Array.<string>} expected Regular expressions describing + * expected script names. + * @return {boolean} Whether all the scripts are in "scripts-files" select + * box + */ +TestSuite.prototype._scriptsAreParsed = function(expected) +{ + var scriptSelect = document.getElementById("scripts-files"); + var options = scriptSelect.options; + + // Check that at least all the expected scripts are present. + var missing = expected.slice(0); + for (var i = 0 ; i < options.length; i++) { + for (var j = 0; j < missing.length; j++) { + if (options[i].text.search(missing[j]) !== -1) { + missing.splice(j, 1); + break; + } + } + } + return missing.length === 0; +}; + + +/** + * Waits for script pause, checks expectations, and invokes the callback. + * @param {Object} expectations Dictionary of expectations + * @param {function():void} callback + */ +TestSuite.prototype._waitForScriptPause = function(expectations, callback) +{ + var test = this; + // Wait until script is paused. + test.addSniffer( + WebInspector, + "pausedScript", + function(callFrames) { + var functionsOnStack = []; + for (var i = 0; i < callFrames.length; i++) + functionsOnStack.push(callFrames[i].functionName); + + test.assertEquals(expectations.functionsOnStack.join(","), functionsOnStack.join(","), "Unexpected stack."); + + // Check that execution line where the script is paused is + // expected one. + test._checkSourceFrameWhenLoaded(expectations, callback); + }); +}; + + +/** + * Waits for current source frame to load, checks expectations, and invokes + * the callback. + * @param {Object} expectations Dictionary of expectations + * @param {function():void} callback + */ +TestSuite.prototype._checkSourceFrameWhenLoaded = function(expectations, callback) +{ + var test = this; + + var frame = WebInspector.currentPanel.visibleView.sourceFrame; + if (frame._loaded) + checkExecLine(); + else { + setTimeout(function() { + test._checkSourceFrameWhenLoaded(expectations, callback); + }, 100); + } + function checkExecLine() { + test._checkExecutionLine(frame, expectations.lineNumber, expectations.lineText); + callback(); + } +}; + + +/** + * Performs sequence of steps. + * @param {Array.<Object|Function>} Array [expectations1,action1,expectations2, + * action2,...,actionN]. + */ +TestSuite.prototype._performSteps = function(actions) +{ + var test = this; + var i = 0; + function doNextAction() { + if (i > 0) + actions[i++](); + if (i < actions.length - 1) + test._waitForScriptPause(actions[i++], doNextAction); + } + doNextAction(); +}; + + +/** + * Waits until all the scripts are parsed and asynchronously executes the code + * in the inspected page. + */ +TestSuite.prototype._executeCodeWhenScriptsAreParsed = function(code, expectedScripts) +{ + var test = this; + + function executeFunctionInInspectedPage() { + // Since breakpoints are ignored in evals' calculate() function is + // execute after zero-timeout so that the breakpoint is hit. + test.evaluateInConsole_( + 'setTimeout("' + code + '" , 0)', + function(resultText) { + test.assertTrue(!isNaN(resultText), "Failed to get timer id: " + resultText); + }); + } + + test._waitUntilScriptsAreParsed(expectedScripts, executeFunctionInInspectedPage); +}; + + +/** + * Waits until all the scripts are parsed and invokes the callback. + */ +TestSuite.prototype._waitUntilScriptsAreParsed = function(expectedScripts, callback) +{ + var test = this; + + function waitForAllScripts() { + if (test._scriptsAreParsed(expectedScripts)) + callback(); + else + test.addSniffer(WebInspector, "parsedScriptSource", waitForAllScripts); + } + + waitForAllScripts(); +}; + + +/** + * Waits until all debugger scripts are parsed and executes "a()" in the + * inspected page. + */ +TestSuite.prototype._executeFunctionForStepTest = function() +{ + this._executeCodeWhenScriptsAreParsed("a()", ["debugger_step.html$", "debugger_step.js$"]); +}; + + +/** + * Tests step over in the debugger. + */ +TestSuite.prototype.testStepOver = function() +{ + this.showPanel("scripts"); + var test = this; + + this._executeFunctionForStepTest(); + + this._performSteps([ + { + functionsOnStack: ["d","a","(anonymous function)"], + lineNumber: 3, + lineText: " debugger;" + }, + function() { + document.getElementById("scripts-step-over").click(); + }, + { + functionsOnStack: ["d","a","(anonymous function)"], + lineNumber: 5, + lineText: " var y = fact(10);" + }, + function() { + document.getElementById("scripts-step-over").click(); + }, + { + functionsOnStack: ["d","a","(anonymous function)"], + lineNumber: 6, + lineText: " return y;" + }, + function() { + test.releaseControl(); + } + ]); + + test.takeControl(); +}; + + +/** + * Tests step out in the debugger. + */ +TestSuite.prototype.testStepOut = function() +{ + this.showPanel("scripts"); + var test = this; + + this._executeFunctionForStepTest(); + + this._performSteps([ + { + functionsOnStack: ["d","a","(anonymous function)"], + lineNumber: 3, + lineText: " debugger;" + }, + function() { + document.getElementById("scripts-step-out").click(); + }, + { + functionsOnStack: ["a","(anonymous function)"], + lineNumber: 8, + lineText: " printResult(result);" + }, + function() { + test.releaseControl(); + } + ]); + + test.takeControl(); +}; + + +/** + * Tests step in in the debugger. + */ +TestSuite.prototype.testStepIn = function() +{ + this.showPanel("scripts"); + var test = this; + + this._executeFunctionForStepTest(); + + this._performSteps([ + { + functionsOnStack: ["d","a","(anonymous function)"], + lineNumber: 3, + lineText: " debugger;" + }, + function() { + document.getElementById("scripts-step-over").click(); + }, + { + functionsOnStack: ["d","a","(anonymous function)"], + lineNumber: 5, + lineText: " var y = fact(10);" + }, + function() { + document.getElementById("scripts-step-into").click(); + }, + { + functionsOnStack: ["fact","d","a","(anonymous function)"], + lineNumber: 15, + lineText: " return r;" + }, + function() { + test.releaseControl(); + } + ]); + + test.takeControl(); +}; + + +/** + * Gets a XPathResult matching given xpath. + * @param {string} xpath + * @param {number} resultType + * @param {Node} opt_ancestor Context node. If not specified documentElement + * will be used + * @return {XPathResult} Type of returned value is determined by "resultType" parameter + */ + +TestSuite.prototype._evaluateXpath = function(xpath, resultType, opt_ancestor) +{ + if (!opt_ancestor) + opt_ancestor = document.documentElement; + try { + return document.evaluate(xpath, opt_ancestor, null, resultType, null); + } catch(e) { + this.fail('Error in expression: "' + xpath + '".' + e); + } +}; + + +/** + * Gets first Node matching given xpath. + * @param {string} xpath + * @param {Node} opt_ancestor Context node. If not specified documentElement + * will be used + * @return {?Node} + */ +TestSuite.prototype._findNode = function(xpath, opt_ancestor) +{ + var result = this._evaluateXpath(xpath, XPathResult.FIRST_ORDERED_NODE_TYPE, opt_ancestor).singleNodeValue; + this.assertTrue(!!result, "Cannot find node on path: " + xpath); + return result; +}; + + +/** + * Gets a text matching given xpath. + * @param {string} xpath + * @param {Node} opt_ancestor Context node. If not specified documentElement + * will be used + * @return {?string} + */ +TestSuite.prototype._findText = function(xpath, opt_ancestor) +{ + var result = this._evaluateXpath(xpath, XPathResult.STRING_TYPE, opt_ancestor).stringValue; + this.assertTrue(!!result, "Cannot find text on path: " + xpath); + return result; +}; + + +/** + * Gets an iterator over nodes matching given xpath. + * @param {string} xpath + * @param {Node} opt_ancestor Context node. If not specified, documentElement + * will be used + * @return {XPathResult} Iterator over the nodes + */ +TestSuite.prototype._nodeIterator = function(xpath, opt_ancestor) +{ + return this._evaluateXpath(xpath, XPathResult.ORDERED_NODE_ITERATOR_TYPE, opt_ancestor); +}; + + +/** + * Checks the scopeSectionDiv against the expectations. + * @param {Node} scopeSectionDiv The section div + * @param {Object} expectations Expectations dictionary + */ +TestSuite.prototype._checkScopeSectionDiv = function(scopeSectionDiv, expectations) +{ + var scopeTitle = this._findText('./div[@class="header"]/div[@class="title"]/text()', scopeSectionDiv); + this.assertEquals(expectations.title, scopeTitle, "Unexpected scope section title."); + if (!expectations.properties) + return; + this.assertTrue(scopeSectionDiv.hasStyleClass("expanded"), 'Section "' + scopeTitle + '" is collapsed.'); + + var propertyIt = this._nodeIterator("./ol/li", scopeSectionDiv); + var propertyLi; + var foundProps = []; + while (propertyLi = propertyIt.iterateNext()) { + var name = this._findText('./span[@class="name"]/text()', propertyLi); + var value = this._findText('./span[@class="value"]/text()', propertyLi); + this.assertTrue(!!name, 'Invalid variable name: "' + name + '"'); + this.assertTrue(name in expectations.properties, "Unexpected property: " + name); + this.assertEquals(expectations.properties[name], value, 'Unexpected "' + name + '" property value.'); + delete expectations.properties[name]; + foundProps.push(name + " = " + value); + } + + // Check that all expected properties were found. + for (var p in expectations.properties) + this.fail('Property "' + p + '" was not found in scope "' + scopeTitle + '". Found properties: "' + foundProps.join(",") + '"'); +}; + + +/** + * Expands scope sections matching the filter and invokes the callback on + * success. + * @param {function(WebInspector.ObjectPropertiesSection, number):boolean} + * filter + * @param {Function} callback + */ +TestSuite.prototype._expandScopeSections = function(filter, callback) +{ + var sections = WebInspector.currentPanel.sidebarPanes.scopechain.sections; + + var toBeUpdatedCount = 0; + function updateListener() { + --toBeUpdatedCount; + if (toBeUpdatedCount === 0) { + // Report when all scopes are expanded and populated. + callback(); + } + } + + // Global scope is always the last one. + for (var i = 0; i < sections.length - 1; i++) { + var section = sections[i]; + if (!filter(sections, i)) + continue; + ++toBeUpdatedCount; + var populated = section.populated; + + this._hookGetPropertiesCallback(updateListener, + function() { + section.expand(); + if (populated) { + // Make sure "updateProperties" callback will be called at least once + // after it was overridden. + section.update(); + } + }); + } +}; + + +/** + * Tests that scopes can be expanded and contain expected data. + */ +TestSuite.prototype.testExpandScope = function() +{ + this.showPanel("scripts"); + var test = this; + + this._executeCodeWhenScriptsAreParsed("handleClick()", ["debugger_closure.html$"]); + + this._waitForScriptPause( + { + functionsOnStack: ["innerFunction", "handleClick", "(anonymous function)"], + lineNumber: 8, + lineText: " debugger;" + }, + expandAllSectionsExceptGlobal); + + // Expanding Global scope takes for too long so we skeep it. + function expandAllSectionsExceptGlobal() { + test._expandScopeSections(function(sections, i) { + return i < sections.length - 1; + }, + examineScopes /* When all scopes are expanded and populated check them. */); + } + + // Check scope sections contents. + function examineScopes() { + var scopeVariablesSection = test._findNode('//div[@id="scripts-sidebar"]/div[div[@class="title"]/text()="Scope Variables"]'); + var expectedScopes = [ + { + title: "Local", + properties: { + x:"2009", + innerFunctionLocalVar:"2011", + "this": "global", + } + }, + { + title: "Closure", + properties: { + n:"TextParam", + makeClosureLocalVar:"local.TextParam", + } + }, + { + title: "Global", + }, + ]; + var it = test._nodeIterator('./div[@class="body"]/div', scopeVariablesSection); + var scopeIndex = 0; + var scopeDiv; + while (scopeDiv = it.iterateNext()) { + test.assertTrue(scopeIndex < expectedScopes.length, "Too many scopes."); + test._checkScopeSectionDiv(scopeDiv, expectedScopes[scopeIndex]); + ++scopeIndex; + } + test.assertEquals(expectedScopes.length, scopeIndex, "Unexpected number of scopes."); + + test.releaseControl(); + } + + test.takeControl(); +}; + + +/** + * Returns child tree element for a property with given name. + * @param {TreeElement} parent Parent tree element. + * @param {string} childName + * @param {string} objectPath Path to the object. Will be printed in the case + * of failure. + * @return {TreeElement} + */ +TestSuite.prototype._findChildProperty = function(parent, childName, objectPath) +{ + var children = parent.children; + for (var i = 0; i < children.length; i++) { + var treeElement = children[i]; + var property = treeElement.property; + if (property.name === childName) + return treeElement; + } + this.fail('Cannot find property "' + childName + '" in ' + objectPath); +}; + + +/** + * Executes the 'code' with InjectedScriptAccess.getProperties overriden + * so that all callbacks passed to InjectedScriptAccess.getProperties are + * extended with the "hook". + * @param {Function} hook The hook function. + * @param {Function} code A code snippet to be executed. + */ +TestSuite.prototype._hookGetPropertiesCallback = function(hook, code) +{ + var accessor = InjectedScriptAccess.prototype; + var orig = accessor.getProperties; + accessor.getProperties = function(objectProxy, ignoreHasOwnProperty, abbreviate, callback) { + orig.call(this, objectProxy, ignoreHasOwnProperty, abbreviate, + function() { + callback.apply(this, arguments); + hook(); + }); + }; + try { + code(); + } finally { + accessor.getProperties = orig; + } +}; + + +/** + * Tests that all elements in prototype chain of an object have expected + * intrinic proprties(__proto__, constructor, prototype). + */ +TestSuite.prototype.testDebugIntrinsicProperties = function() +{ + this.showPanel("scripts"); + var test = this; + + this._executeCodeWhenScriptsAreParsed("handleClick()", ["debugger_intrinsic_properties.html$"]); + + this._waitForScriptPause( + { + functionsOnStack: ["callDebugger", "handleClick", "(anonymous function)"], + lineNumber: 29, + lineText: " debugger;" + }, + expandLocalScope); + + var localScopeSection = null; + function expandLocalScope() { + test._expandScopeSections(function(sections, i) { + if (i === 0) { + test.assertTrue(sections[i].object.isLocal, "Scope #0 is not Local."); + localScopeSection = sections[i]; + return true; + } + return false; + }, + examineLocalScope); + } + + function examineLocalScope() { + var scopeExpectations = [ + "a", "Object", [ + "constructor", "function Child()", [ + "constructor", "function Function()", null, + "name", "Child", null, + "prototype", "Object", [ + "childProtoField", 21, null + ] + ], + + "__proto__", "Object", [ + "__proto__", "Object", [ + "__proto__", "Object", [ + "__proto__", "null", null, + "constructor", "function Object()", null, + ], + "constructor", "function Parent()", [ + "name", "Parent", null, + "prototype", "Object", [ + "parentProtoField", 11, null, + ] + ], + "parentProtoField", 11, null, + ], + "constructor", "function Child()", null, + "childProtoField", 21, null, + ], + + "parentField", 10, null, + "childField", 20, null, + ] + ]; + + checkProperty(localScopeSection.propertiesTreeOutline, "<Local Scope>", scopeExpectations); + } + + var propQueue = []; + var index = 0; + var expectedFinalIndex = 8; + + function expandAndCheckNextProperty() { + if (index === propQueue.length) { + test.assertEquals(expectedFinalIndex, index, "Unexpected number of expanded objects."); + test.releaseControl(); + return; + } + + // Read next property data from the queue. + var treeElement = propQueue[index].treeElement; + var path = propQueue[index].path; + var expectations = propQueue[index].expectations; + index++; + + // Expand the property. + test._hookGetPropertiesCallback(function() { + checkProperty(treeElement, path, expectations); + }, + function() { + treeElement.expand(); + }); + } + + function checkProperty(treeElement, path, expectations) { + for (var i = 0; i < expectations.length; i += 3) { + var name = expectations[i]; + var description = expectations[i+1]; + var value = expectations[i+2]; + + var propertyPath = path + "." + name; + var propertyTreeElement = test._findChildProperty(treeElement, name, path); + test.assertTrue(propertyTreeElement, 'Property "' + propertyPath + '" not found.'); + test.assertEquals(description, propertyTreeElement.property.value.description, 'Unexpected "' + propertyPath + '" description.'); + if (value) { + // Schedule property content check. + propQueue.push({ + treeElement: propertyTreeElement, + path: propertyPath, + expectations: value, + }); + } + } + // Check next property in the queue. + expandAndCheckNextProperty(); + } + + test.takeControl(); +}; + + +/** + * Tests "Pause" button will pause debugger when a snippet is evaluated. + */ +TestSuite.prototype.testPauseInEval = function() +{ + this.showPanel("scripts"); + + var test = this; + + var pauseButton = document.getElementById("scripts-pause"); + pauseButton.click(); + + devtools.tools.evaluateJavaScript("fib(10)"); + + this.addSniffer(WebInspector, "pausedScript", + function() { + test.releaseControl(); + }); + + test.takeControl(); +}; + + +/** + * Key event with given key identifier. + */ +TestSuite.createKeyEvent = function(keyIdentifier) +{ + var evt = document.createEvent("KeyboardEvent"); + evt.initKeyboardEvent("keydown", true /* can bubble */, true /* can cancel */, null /* view */, keyIdentifier, ""); + return evt; +}; + + +/** + * Tests console eval. + */ +TestSuite.prototype.testConsoleEval = function() +{ + var test = this; + this.evaluateInConsole_("123", + function(resultText) { + test.assertEquals("123", resultText); + test.releaseControl(); + }); + + this.takeControl(); +}; + + +/** + * Tests console log. + */ +TestSuite.prototype.testConsoleLog = function() +{ + WebInspector.console.visible = true; + var messages = WebInspector.console.messages; + var index = 0; + + var test = this; + var assertNext = function(line, message, opt_class, opt_count, opt_substr) { + var elem = messages[index++].toMessageElement(); + var clazz = elem.getAttribute("class"); + var expectation = (opt_count || '') + 'console_test_page.html:' + line + message; + if (opt_substr) + test.assertContains(elem.textContent, expectation); + else + test.assertEquals(expectation, elem.textContent); + if (opt_class) + test.assertContains(clazz, "console-" + opt_class); + }; + + assertNext("5", "log", "log-level"); + assertNext("7", "debug", "log-level"); + assertNext("9", "info", "log-level"); + assertNext("11", "warn", "warning-level"); + assertNext("13", "error", "error-level"); + assertNext("15", "Message format number 1, 2 and 3.5"); + assertNext("17", "Message format for string"); + assertNext("19", "Object Object"); + assertNext("22", "repeated", "log-level", 5); + assertNext("26", "count: 1"); + assertNext("26", "count: 2"); + assertNext("29", "group", "group-title"); + index++; + assertNext("33", "timer:", "log-level", "", true); + assertNext("35", "1 2 3", "log-level"); + assertNext("37", "HTMLDocument", "log-level"); + assertNext("39", "<html>", "log-level", "", true); +}; + + +/** + * Tests eval of global objects. + */ +TestSuite.prototype.testEvalGlobal = function() +{ + WebInspector.console.visible = true; + + var inputs = ["foo", "foobar"]; + var expectations = ["foo", "fooValue", "foobar", "ReferenceError: foobar is not defined"]; + + // Do not change code below - simply add inputs and expectations above. + var initEval = function(input) { + WebInspector.console.prompt.text = input; + WebInspector.console.promptElement.dispatchEvent( TestSuite.createKeyEvent("Enter")); + }; + var test = this; + var messagesCount = 0; + var inputIndex = 0; + this.addSniffer(WebInspector.ConsoleView.prototype, "addMessage", + function(commandResult) { + messagesCount++; + if (messagesCount === expectations.length) { + var messages = WebInspector.console.messages; + for (var i = 0; i < expectations; ++i) { + var elem = messages[i++].toMessageElement(); + test.assertEquals(elem.textContent, expectations[i]); + } + test.releaseControl(); + } else if (messagesCount % 2 === 0) + initEval(inputs[inputIndex++]); + }, true); + + initEval(inputs[inputIndex++]); + this.takeControl(); +}; + + +/** + * Tests that Storage panel can be open and that local DOM storage is added + * to the panel. + */ +TestSuite.prototype.testShowStoragePanel = function() +{ + var test = this; + this.addSniffer(WebInspector.panels.storage, "addDOMStorage", + function(storage) { + var orig = storage.getEntries; + storage.getEntries = function(callback) { + orig.call(this, function(entries) { + callback(entries); + test.releaseControl(); + }); + }; + try { + WebInspector.currentPanel.selectDOMStorage(storage.id); + storage.getEntries = orig; + } catch (e) { + test.fail("Exception in selectDOMStorage: " + e); + } + }); + this.showPanel("storage"); + + // Access localStorage so that it's pushed to the frontend. + this.evaluateInConsole_( + 'setTimeout("localStorage.x = 10" , 0)', + function(resultText) { + test.assertTrue(!isNaN(resultText), "Failed to get timer id: " + resultText); + }); + + // Wait until DOM storage is added to the panel. + this.takeControl(); +}; + + +/** + * Test runner for the test suite. + */ +var uiTests = {}; + + +/** + * Run each test from the test suit on a fresh instance of the suite. + */ +uiTests.runAllTests = function() +{ + // For debugging purposes. + for (var name in TestSuite.prototype) { + if (name.substring(0, 4) === "test" && typeof TestSuite.prototype[name] === "function") + uiTests.runTest(name); + } +}; + + +/** + * Run specified test on a fresh instance of the test suite. + * @param {string} name Name of a test method from TestSuite class. + */ +uiTests.runTest = function(name) +{ + new TestSuite().runTest(name); +}; + + +} diff --git a/WebKit/chromium/src/js/devTools.css b/WebKit/chromium/src/js/devTools.css new file mode 100755 index 0000000..1fa935f --- /dev/null +++ b/WebKit/chromium/src/js/devTools.css @@ -0,0 +1,223 @@ +#scripts-files option.injected { + color: rgb(70, 134, 240); +} + +.data-grid table { + line-height: 120%; +} + +body.attached #toolbar { + height: 34px; + border-top: 1px solid rgb(100, 100, 100); + cursor: default; /* overriden */ + padding-left: 0; +} + + +/* Chrome theme overrides */ +body.platform-windows #toolbar { + background-image: -webkit-gradient(linear, left top, left bottom, from(rgb(242, 247, 253)), to(rgb(223, 234, 248))); +} + +body.platform-windows.inactive #toolbar { + background-image: -webkit-gradient(linear, left top, left bottom, from(rgb(248, 248, 248)), to(rgb(237, 237, 237))); +} + + +/* Heap Profiler Styles */ + +.heap-snapshot-status-bar-item .glyph { + -webkit-mask-image: url(Images/focusButtonGlyph.png); +} + +.heap-snapshot-sidebar-tree-item .icon { + content: url(Images/profileIcon.png); +} + +.heap-snapshot-sidebar-tree-item.small .icon { + content: url(Images/profileSmallIcon.png); +} + +.heap-snapshot-view { + display: none; + overflow: hidden; + position: absolute; + top: 0; + left: 0; + right: 0; + bottom: 0; +} + +.heap-snapshot-view.visible { + display: block; +} + +.heap-snapshot-view .data-grid { + border: none; + max-height: 100%; + position: absolute; + left: 0; + right: 0; + top: 0; + bottom: 93px; +} + +.heap-snapshot-view .data-grid th.count-column { + text-align: center; +} + +.heap-snapshot-view .data-grid td.count-column { + text-align: right; +} + +.heap-snapshot-view .data-grid th.size-column { + text-align: center; +} + +.heap-snapshot-view .data-grid td.size-column { + text-align: right; +} + +.heap-snapshot-view .data-grid th.countDelta-column { + text-align: center; +} + +.heap-snapshot-view .data-grid td.countDelta-column { + text-align: right; +} + +.heap-snapshot-view .data-grid th.sizeDelta-column { + text-align: center; +} + +.heap-snapshot-view .data-grid td.sizeDelta-column { + text-align: right; +} + +#heap-snapshot-summary-container { + position: absolute; + padding-top: 20px; + bottom: 0; + left: 0; + right: 0; + height: 93px; + margin-left: -1px; + border-left: 1px solid rgb(102, 102, 102); + background-color: rgb(101, 111, 130); + background-image: -webkit-gradient(linear, left top, left bottom, from(rgba(0, 0, 0, 0.5)), to(rgba(0, 0, 0, 0))); + background-repeat: repeat-x; + background-position: top; + text-align: center; + text-shadow: black 0 1px 1px; + white-space: nowrap; + color: white; + -webkit-background-size: 1px 6px; + -webkit-background-origin: padding; + -webkit-background-clip: padding; +} + +.heap-snapshot-summary { + display: inline-block; + width: 50%; + min-width: 300px; + position: relative; +} + +.heap-snapshot-summary canvas.summary-graph { + width: 225px; +} + +.heap-snapshot-summary-label { + font-size: 12px; + font-weight: bold; + position: absolute; + top: 1px; + width: 50%; + left: 25%; +} + +body.platform-windows .section > .header { + border: 1px solid rgb(92, 116, 157); + background-image: -webkit-gradient(linear, left top, left bottom, from(rgb(105, 133, 180)), to(rgb(92, 116, 157))); +} + +body.platform-windows .console-group-messages .section > .header { + padding: 0 8px 0 0; + background-image: none; + border: none; + min-height: 0; +} + +body.platform-windows #resources-filter { + background: -webkit-gradient(linear, left top, left bottom, from(rgb(233, 233, 233)), to(rgb(233, 233, 233))); +} + +body.platform-windows .crumbs .crumb { + -webkit-border-image: url(Images/segmentChromium.png) 0 12 0 2; +} + +body.platform-windows .crumbs .crumb.end { + -webkit-border-image: url(Images/segmentEndChromium.png) 0 2 0 2; +} + +body.platform-windows .crumbs .crumb.selected { + -webkit-border-image: url(Images/segmentSelectedChromium.png) 0 12 0 2; + color: white; + text-shadow: rgba(255, 255, 255, 0.5) 0 0px 0; +} + +body.platform-windows .crumbs .crumb.selected:hover { + -webkit-border-image: url(Images/segmentSelectedChromium.png) 0 12 0 2; +} + +body.platform-windows .crumbs .crumb.selected.end, .crumbs .crumb.selected.end:hover { + -webkit-border-image: url(Images/segmentSelectedEndChromium.png) 0 2 0 2; +} + +body.platform-windows .crumbs .crumb:hover { + -webkit-border-image: url(Images/segmentHoverChromium.png) 0 12 0 2; +} + +body.platform-windows .crumbs .crumb.dimmed:hover { + -webkit-border-image: url(Images/segmentHoverChromium.png) 0 12 0 2; +} + +body.platform-windows .crumbs .crumb.end:hover { + -webkit-border-image: url(Images/segmentHoverEndChromium.png) 0 2 0 2; +} + +body.platform-windows body.drawer-visible #main-status-bar { + background-image: url(Images/statusbarResizerVertical.png), url(Images/statusbarBackgroundChromium.png); +} + +body.platform-windows .status-bar { + background-image: url(Images/statusbarBackgroundChromium.png); +} + +body.platform-windows button.status-bar-item { + background-image: url(Images/statusbarButtonsChromium.png); +} + +body.platform-windows select.status-bar-item:active { + -webkit-border-image: url(Images/statusbarMenuButtonSelectedChromium.png) 0 17 0 2; +} + +body.platform-windows #drawer { + background-image: url(Images/statusbarBottomBackgroundChromium.png); +} + +body.platform-windows select.status-bar-item { + -webkit-border-image: url(Images/statusbarMenuButtonChromium.png) 0 17 0 2; +} + +.scope-bar li.selected { + -webkit-box-shadow: 0px 0px 0px rgba(0, 0, 0, 0.0); +} + +.scope-bar li:active { + -webkit-box-shadow: 0px 0px 0px rgba(0, 0, 0, 0.0); +} + +.timeline-category-tree-item input { + vertical-align: middle; +} 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/linux/WebRenderTheme.cpp b/WebKit/chromium/src/linux/WebRenderTheme.cpp new file mode 100644 index 0000000..16ea22c --- /dev/null +++ b/WebKit/chromium/src/linux/WebRenderTheme.cpp @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2010 Joel Stanley. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (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 "WebRenderTheme.h" + +#include "RenderThemeChromiumLinux.h" +#include "WebView.h" + +using WebCore::RenderTheme; +using WebCore::RenderThemeChromiumLinux; + +namespace WebKit { + +void setCaretBlinkInterval(double interval) +{ + RenderThemeChromiumLinux::setCaretBlinkInterval(interval); +} + +} // namespace WebKit diff --git a/WebKit/chromium/src/mac/WebInputEventFactory.mm b/WebKit/chromium/src/mac/WebInputEventFactory.mm new file mode 100644 index 0000000..46b0afe --- /dev/null +++ b/WebKit/chromium/src/mac/WebInputEventFactory.mm @@ -0,0 +1,1199 @@ +/* + * 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; + } + + if ([event modifierFlags] & NSNumericPadKeyMask) + return true; + + 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/tests/KURLTest.cpp b/WebKit/chromium/tests/KURLTest.cpp new file mode 100644 index 0000000..b316683 --- /dev/null +++ b/WebKit/chromium/tests/KURLTest.cpp @@ -0,0 +1,611 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +// Basic tests that verify our KURL's interface behaves the same as the +// original KURL's. + +#include "config.h" + +#include <gtest/gtest.h> + +#include "KURL.h" + +namespace { + +// Output stream operator so gTest's macros work with WebCore strings. +std::ostream& operator<<(std::ostream& out, const WebCore::String& str) +{ + return str.isEmpty() ? out : out << str.utf8().data(); +} + +struct ComponentCase { + const char* url; + const char* protocol; + const char* host; + const int port; + const char* user; + const char* pass; + const char* path; + const char* lastPath; + const char* query; + const char* ref; +}; + +// Test the cases where we should be the same as WebKit's old KURL. +TEST(KURLTest, SameGetters) +{ + struct GetterCase { + const char* url; + const char* protocol; + const char* host; + int port; + const char* user; + const char* pass; + const char* lastPathComponent; + const char* query; + const char* ref; + bool hasRef; + } cases[] = { + {"http://www.google.com/foo/blah?bar=baz#ref", "http", "www.google.com", 0, "", 0, "blah", "bar=baz", "ref", true}, + {"http://foo.com:1234/foo/bar/", "http", "foo.com", 1234, "", 0, "bar", 0, 0, false}, + {"http://www.google.com?#", "http", "www.google.com", 0, "", 0, 0, "", "", true}, + {"https://me:pass@google.com:23#foo", "https", "google.com", 23, "me", "pass", 0, 0, "foo", true}, + {"javascript:hello!//world", "javascript", "", 0, "", 0, "world", 0, 0, false}, + }; + + for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) { + // UTF-8 + WebCore::KURL kurl(WebCore::ParsedURLString, cases[i].url); + + EXPECT_EQ(cases[i].protocol, kurl.protocol()); + EXPECT_EQ(cases[i].host, kurl.host()); + EXPECT_EQ(cases[i].port, kurl.port()); + EXPECT_EQ(cases[i].user, kurl.user()); + EXPECT_EQ(cases[i].pass, kurl.pass()); + EXPECT_EQ(cases[i].lastPathComponent, kurl.lastPathComponent()); + EXPECT_EQ(cases[i].query, kurl.query()); + EXPECT_EQ(cases[i].ref, kurl.fragmentIdentifier()); + EXPECT_EQ(cases[i].hasRef, kurl.hasFragmentIdentifier()); + + // UTF-16 + WebCore::String utf16(cases[i].url); + kurl = WebCore::KURL(WebCore::ParsedURLString, utf16); + + EXPECT_EQ(cases[i].protocol, kurl.protocol()); + EXPECT_EQ(cases[i].host, kurl.host()); + EXPECT_EQ(cases[i].port, kurl.port()); + EXPECT_EQ(cases[i].user, kurl.user()); + EXPECT_EQ(cases[i].pass, kurl.pass()); + EXPECT_EQ(cases[i].lastPathComponent, kurl.lastPathComponent()); + EXPECT_EQ(cases[i].query, kurl.query()); + EXPECT_EQ(cases[i].ref, kurl.fragmentIdentifier()); + EXPECT_EQ(cases[i].hasRef, kurl.hasFragmentIdentifier()); + } +} + +// Test a few cases where we're different just to make sure we give reasonable +// output. +TEST(KURLTest, DifferentGetters) +{ + ComponentCase cases[] = { + // url protocol host port user pass path lastPath query ref + + // Old WebKit allows references and queries in what we call "path" URLs + // like javascript, so the path here will only consist of "hello!". + {"javascript:hello!?#/\\world", "javascript", "", 0, "", 0, "hello!?#/\\world", "world", 0, 0}, + + // Old WebKit doesn't handle "parameters" in paths, so will + // disagree with us about where the path is for this URL. + {"http://a.com/hello;world", "http", "a.com", 0, "", 0, "/hello;world", "hello", 0, 0}, + + // WebKit doesn't like UTF-8 or UTF-16 input. + {"http://\xe4\xbd\xa0\xe5\xa5\xbd\xe4\xbd\xa0\xe5\xa5\xbd/", "http", "xn--6qqa088eba", 0, "", 0, "/", 0, 0, 0}, + + // WebKit %-escapes non-ASCII characters in reference, but we don't. + {"http://www.google.com/foo/blah?bar=baz#\xce\xb1\xce\xb2", "http", "www.google.com", 0, "", 0, "/foo/blah/", "blah", "bar=baz", "\xce\xb1\xce\xb2"}, + }; + + for (size_t i = 0; i < arraysize(cases); i++) { + WebCore::KURL kurl(WebCore::ParsedURLString, cases[i].url); + + EXPECT_EQ(cases[i].protocol, kurl.protocol()); + EXPECT_EQ(cases[i].host, kurl.host()); + EXPECT_EQ(cases[i].port, kurl.port()); + EXPECT_EQ(cases[i].user, kurl.user()); + EXPECT_EQ(cases[i].pass, kurl.pass()); + EXPECT_EQ(cases[i].lastPath, kurl.lastPathComponent()); + EXPECT_EQ(cases[i].query, kurl.query()); + // Want to compare UCS-16 refs (or to null). + if (cases[i].ref) + EXPECT_EQ(WebCore::String::fromUTF8(cases[i].ref), kurl.fragmentIdentifier()); + else + EXPECT_TRUE(kurl.fragmentIdentifier().isNull()); + } +} + +// Ensures that both ASCII and UTF-8 canonical URLs are handled properly and we +// get the correct string object out. +TEST(KURLTest, UTF8) +{ + const char asciiURL[] = "http://foo/bar#baz"; + WebCore::KURL asciiKURL(WebCore::ParsedURLString, asciiURL); + EXPECT_TRUE(asciiKURL.string() == WebCore::String(asciiURL)); + + // When the result is ASCII, we should get an ASCII String. Some + // code depends on being able to compare the result of the .string() + // getter with another String, and the isASCIIness of the two + // strings must match for these functions (like equalIgnoringCase). + EXPECT_TRUE(WebCore::equalIgnoringCase(asciiKURL, WebCore::String(asciiURL))); + + // Reproduce code path in FrameLoader.cpp -- equalIgnoringCase implicitly + // expects gkurl.protocol() to have been created as ascii. + WebCore::KURL mailto(WebCore::ParsedURLString, "mailto:foo@foo.com"); + EXPECT_TRUE(WebCore::equalIgnoringCase(mailto.protocol(), "mailto")); + + const char utf8URL[] = "http://foo/bar#\xe4\xbd\xa0\xe5\xa5\xbd"; + WebCore::KURL utf8KURL(WebCore::ParsedURLString, utf8URL); + + EXPECT_TRUE(utf8KURL.string() == WebCore::String::fromUTF8(utf8URL)); +} + +TEST(KURLTest, Setters) +{ + // Replace the starting URL with the given components one at a time and + // verify that we're always the same as the old KURL. + // + // Note that old KURL won't canonicalize the default port away, so we + // can't set setting the http port to "80" (or even "0"). + // + // We also can't test clearing the query. + // + // The format is every other row is a test, and the row that follows it is the + // expected result. + struct ExpectedComponentCase { + const char* url; + const char* protocol; + const char* host; + const int port; + const char* user; + const char* pass; + const char* path; + const char* query; + const char* ref; + + // The full expected URL with the given "set" applied. + const char* expectedProtocol; + const char* expectedHost; + const char* expectedPort; + const char* expectedUser; + const char* expectedPass; + const char* expectedPath; + const char* expectedQuery; + const char* expectedRef; + } cases[] = { + // url protocol host port user pass path query ref + {"http://www.google.com/", "https", "news.google.com", 8888, "me", "pass", "/foo", "?q=asdf", "heehee", + "https://www.google.com/", + "https://news.google.com/", + "https://news.google.com:8888/", + "https://me@news.google.com:8888/", + "https://me:pass@news.google.com:8888/", + "https://me:pass@news.google.com:8888/foo", + "https://me:pass@news.google.com:8888/foo?q=asdf", + "https://me:pass@news.google.com:8888/foo?q=asdf#heehee"}, + + {"https://me:pass@google.com:88/a?f#b", "http", "goo.com", 92, "", "", "/", 0, "", + "http://me:pass@google.com:88/a?f#b", + "http://me:pass@goo.com:88/a?f#b", + "http://me:pass@goo.com:92/a?f#b", + "http://:pass@goo.com:92/a?f#b", + "http://goo.com:92/a?f#b", + "http://goo.com:92/?f#b", + "http://goo.com:92/#b", + "https://goo.com:92/"}, + }; + + for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) { + WebCore::KURL kurl(WebCore::ParsedURLString, cases[i].url); + + kurl.setProtocol(cases[i].protocol); + EXPECT_STREQ(cases[i].expectedProtocol, kurl.string().utf8().data()); + + kurl.setHost(cases[i].host); + EXPECT_STREQ(cases[i].expectedHost, kurl.string().utf8().data()); + + kurl.setPort(cases[i].port); + EXPECT_STREQ(cases[i].expectedPort, kurl.string().utf8().data()); + + kurl.setUser(cases[i].user); + EXPECT_STREQ(cases[i].expectedUser, kurl.string().utf8().data()); + + kurl.setPass(cases[i].pass); + EXPECT_STREQ(cases[i].expectedPass, kurl.string().utf8().data()); + + kurl.setPath(cases[i].path); + EXPECT_STREQ(cases[i].expectedPath, kurl.string().utf8().data()); + + kurl.setQuery(cases[i].query); + EXPECT_STREQ(cases[i].expectedQuery, kurl.string().utf8().data()); + + // Refs are tested below. On the Safari 3.1 branch, we don't match their + // KURL since we integrated a fix from their trunk. + } +} + +// Tests that KURL::decodeURLEscapeSequences works as expected +#if USE(GOOGLEURL) +TEST(KURLTest, Decode) +{ + struct DecodeCase { + const char* input; + const char* output; + } decodeCases[] = { + {"hello, world", "hello, world"}, + {"%01%02%03%04%05%06%07%08%09%0a%0B%0C%0D%0e%0f/", "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0B\x0C\x0D\x0e\x0f/"}, + {"%10%11%12%13%14%15%16%17%18%19%1a%1B%1C%1D%1e%1f/", "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1B\x1C\x1D\x1e\x1f/"}, + {"%20%21%22%23%24%25%26%27%28%29%2a%2B%2C%2D%2e%2f/", " !\"#$%&'()*+,-.//"}, + {"%30%31%32%33%34%35%36%37%38%39%3a%3B%3C%3D%3e%3f/", "0123456789:;<=>?/"}, + {"%40%41%42%43%44%45%46%47%48%49%4a%4B%4C%4D%4e%4f/", "@ABCDEFGHIJKLMNO/"}, + {"%50%51%52%53%54%55%56%57%58%59%5a%5B%5C%5D%5e%5f/", "PQRSTUVWXYZ[\\]^_/"}, + {"%60%61%62%63%64%65%66%67%68%69%6a%6B%6C%6D%6e%6f/", "`abcdefghijklmno/"}, + {"%70%71%72%73%74%75%76%77%78%79%7a%7B%7C%7D%7e%7f/", "pqrstuvwxyz{|}~\x7f/"}, + // Test un-UTF-8-ization. + {"%e4%bd%a0%e5%a5%bd", "\xe4\xbd\xa0\xe5\xa5\xbd"}, + }; + + for (size_t i = 0; i < ARRAYSIZE_UNSAFE(decodeCases); i++) { + WebCore::String input(decodeCases[i].input); + WebCore::String str = WebCore::decodeURLEscapeSequences(input); + EXPECT_STREQ(decodeCases[i].output, str.utf8().data()); + } + + // Our decode should decode %00 + WebCore::String zero = WebCore::decodeURLEscapeSequences("%00"); + EXPECT_STRNE("%00", zero.utf8().data()); + + // Test the error behavior for invalid UTF-8 (we differ from WebKit here). + WebCore::String invalid = WebCore::decodeURLEscapeSequences( + "%e4%a0%e5%a5%bd"); + char16 invalidExpectedHelper[4] = { 0x00e4, 0x00a0, 0x597d, 0 }; + WebCore::String invalidExpected( + reinterpret_cast<const ::UChar*>(invalidExpectedHelper), + 3); + EXPECT_EQ(invalidExpected, invalid); +} +#endif + +TEST(KURLTest, Encode) +{ + // Also test that it gets converted to UTF-8 properly. + char16 wideInputHelper[3] = { 0x4f60, 0x597d, 0 }; + WebCore::String wideInput( + reinterpret_cast<const ::UChar*>(wideInputHelper), 2); + WebCore::String wideReference("\xe4\xbd\xa0\xe5\xa5\xbd", 6); + WebCore::String wideOutput = + WebCore::encodeWithURLEscapeSequences(wideInput); + EXPECT_EQ(wideReference, wideOutput); + + // Our encode only escapes NULLs for safety (see the implementation for + // more), so we only bother to test a few cases. + WebCore::String input( + "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", 16); + WebCore::String reference( + "%00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", 18); + WebCore::String output = WebCore::encodeWithURLEscapeSequences(input); + EXPECT_EQ(reference, output); +} + +TEST(KURLTest, ResolveEmpty) +{ + WebCore::KURL emptyBase; + + // WebKit likes to be able to resolve absolute input agains empty base URLs, + // which would normally be invalid since the base URL is invalid. + const char abs[] = "http://www.google.com/"; + WebCore::KURL resolveAbs(emptyBase, abs); + EXPECT_TRUE(resolveAbs.isValid()); + EXPECT_STREQ(abs, resolveAbs.string().utf8().data()); + + // Resolving a non-relative URL agains the empty one should still error. + const char rel[] = "foo.html"; + WebCore::KURL resolveErr(emptyBase, rel); + EXPECT_FALSE(resolveErr.isValid()); +} + +// WebKit will make empty URLs and set components on them. kurl doesn't allow +// replacements on invalid URLs, but here we do. +TEST(KURLTest, ReplaceInvalid) +{ + WebCore::KURL kurl; + + EXPECT_FALSE(kurl.isValid()); + EXPECT_TRUE(kurl.isEmpty()); + EXPECT_STREQ("", kurl.string().utf8().data()); + + kurl.setProtocol("http"); + // GKURL will say that a URL with just a scheme is invalid, KURL will not. +#if USE(GOOGLEURL) + EXPECT_FALSE(kurl.isValid()); +#else + EXPECT_TRUE(kurl.isValid()); +#endif + EXPECT_FALSE(kurl.isEmpty()); + // At this point, we do things slightly differently if there is only a scheme. + // We check the results here to make it more obvious what is going on, but it + // shouldn't be a big deal if these change. +#if USE(GOOGLEURL) + EXPECT_STREQ("http:", kurl.string().utf8().data()); +#else + EXPECT_STREQ("http:/", kurl.string().utf8().data()); +#endif + + kurl.setHost("www.google.com"); + EXPECT_TRUE(kurl.isValid()); + EXPECT_FALSE(kurl.isEmpty()); + EXPECT_STREQ("http://www.google.com/", kurl.string().utf8().data()); + + kurl.setPort(8000); + EXPECT_TRUE(kurl.isValid()); + EXPECT_FALSE(kurl.isEmpty()); + EXPECT_STREQ("http://www.google.com:8000/", kurl.string().utf8().data()); + + kurl.setPath("/favicon.ico"); + EXPECT_TRUE(kurl.isValid()); + EXPECT_FALSE(kurl.isEmpty()); + EXPECT_STREQ("http://www.google.com:8000/favicon.ico", kurl.string().utf8().data()); + + // Now let's test that giving an invalid replacement still fails. +#if USE(GOOGLEURL) + kurl.setProtocol("f/sj#@"); + EXPECT_FALSE(kurl.isValid()); +#endif +} + +TEST(KURLTest, Path) +{ + const char initial[] = "http://www.google.com/path/foo"; + WebCore::KURL kurl(WebCore::ParsedURLString, initial); + + // Clear by setting a null string. + WebCore::String nullString; + EXPECT_TRUE(nullString.isNull()); + kurl.setPath(nullString); + EXPECT_STREQ("http://www.google.com/", kurl.string().utf8().data()); +} + +// Test that setting the query to different things works. Thq query is handled +// a littler differently than some of the other components. +TEST(KURLTest, Query) +{ + const char initial[] = "http://www.google.com/search?q=awesome"; + WebCore::KURL kurl(WebCore::ParsedURLString, initial); + + // Clear by setting a null string. + WebCore::String nullString; + EXPECT_TRUE(nullString.isNull()); + kurl.setQuery(nullString); + EXPECT_STREQ("http://www.google.com/search", kurl.string().utf8().data()); + + // Clear by setting an empty string. + kurl = WebCore::KURL(WebCore::ParsedURLString, initial); + WebCore::String emptyString(""); + EXPECT_FALSE(emptyString.isNull()); + kurl.setQuery(emptyString); + EXPECT_STREQ("http://www.google.com/search?", kurl.string().utf8().data()); + + // Set with something that begins in a question mark. + const char question[] = "?foo=bar"; + kurl.setQuery(question); + EXPECT_STREQ("http://www.google.com/search?foo=bar", + kurl.string().utf8().data()); + + // Set with something that doesn't begin in a question mark. + const char query[] = "foo=bar"; + kurl.setQuery(query); + EXPECT_STREQ("http://www.google.com/search?foo=bar", + kurl.string().utf8().data()); +} + +TEST(KURLTest, Ref) +{ + WebCore::KURL kurl(WebCore::ParsedURLString, "http://foo/bar#baz"); + + // Basic ref setting. + WebCore::KURL cur(WebCore::ParsedURLString, "http://foo/bar"); + cur.setFragmentIdentifier("asdf"); + EXPECT_STREQ("http://foo/bar#asdf", cur.string().utf8().data()); + cur = kurl; + cur.setFragmentIdentifier("asdf"); + EXPECT_STREQ("http://foo/bar#asdf", cur.string().utf8().data()); + + // Setting a ref to the empty string will set it to "#". + cur = WebCore::KURL(WebCore::ParsedURLString, "http://foo/bar"); + cur.setFragmentIdentifier(""); + EXPECT_STREQ("http://foo/bar#", cur.string().utf8().data()); + cur = kurl; + cur.setFragmentIdentifier(""); + EXPECT_STREQ("http://foo/bar#", cur.string().utf8().data()); + + // Setting the ref to the null string will clear it altogether. + cur = WebCore::KURL(WebCore::ParsedURLString, "http://foo/bar"); + cur.setFragmentIdentifier(WebCore::String()); + EXPECT_STREQ("http://foo/bar", cur.string().utf8().data()); + cur = kurl; + cur.setFragmentIdentifier(WebCore::String()); + EXPECT_STREQ("http://foo/bar", cur.string().utf8().data()); +} + +TEST(KURLTest, Empty) +{ + WebCore::KURL kurl; + + // First test that regular empty URLs are the same. + EXPECT_TRUE(kurl.isEmpty()); + EXPECT_FALSE(kurl.isValid()); + EXPECT_TRUE(kurl.isNull()); + EXPECT_TRUE(kurl.string().isNull()); + EXPECT_TRUE(kurl.string().isEmpty()); + + // Test resolving a null URL on an empty string. + WebCore::KURL kurl2(kurl, ""); + EXPECT_FALSE(kurl2.isNull()); + EXPECT_TRUE(kurl2.isEmpty()); + EXPECT_FALSE(kurl2.isValid()); + EXPECT_FALSE(kurl2.string().isNull()); + EXPECT_TRUE(kurl2.string().isEmpty()); + EXPECT_FALSE(kurl2.string().isNull()); + EXPECT_TRUE(kurl2.string().isEmpty()); + + // Resolve the null URL on a null string. + WebCore::KURL kurl22(kurl, WebCore::String()); + EXPECT_FALSE(kurl22.isNull()); + EXPECT_TRUE(kurl22.isEmpty()); + EXPECT_FALSE(kurl22.isValid()); + EXPECT_FALSE(kurl22.string().isNull()); + EXPECT_TRUE(kurl22.string().isEmpty()); + EXPECT_FALSE(kurl22.string().isNull()); + EXPECT_TRUE(kurl22.string().isEmpty()); + + // Test non-hierarchical schemes resolving. The actual URLs will be different. + // WebKit's one will set the string to "something.gif" and we'll set it to an + // empty string. I think either is OK, so we just check our behavior. +#if USE(GOOGLEURL) + WebCore::KURL kurl3(WebCore::KURL(WebCore::ParsedURLString, "data:foo"), + "something.gif"); + EXPECT_TRUE(kurl3.isEmpty()); + EXPECT_FALSE(kurl3.isValid()); +#endif + + // Test for weird isNull string input, + // see: http://bugs.webkit.org/show_bug.cgi?id=16487 + WebCore::KURL kurl4(WebCore::ParsedURLString, kurl.string()); + EXPECT_TRUE(kurl4.isEmpty()); + EXPECT_FALSE(kurl4.isValid()); + EXPECT_TRUE(kurl4.string().isNull()); + EXPECT_TRUE(kurl4.string().isEmpty()); + + // Resolving an empty URL on an invalid string. + WebCore::KURL kurl5(WebCore::KURL(), "foo.js"); + // We'll be empty in this case, but KURL won't be. Should be OK. + // EXPECT_EQ(kurl5.isEmpty(), kurl5.isEmpty()); + // EXPECT_EQ(kurl5.string().isEmpty(), kurl5.string().isEmpty()); + EXPECT_FALSE(kurl5.isValid()); + EXPECT_FALSE(kurl5.string().isNull()); + + // Empty string as input + WebCore::KURL kurl6(WebCore::ParsedURLString, ""); + EXPECT_TRUE(kurl6.isEmpty()); + EXPECT_FALSE(kurl6.isValid()); + EXPECT_FALSE(kurl6.string().isNull()); + EXPECT_TRUE(kurl6.string().isEmpty()); + + // Non-empty but invalid C string as input. + WebCore::KURL kurl7(WebCore::ParsedURLString, "foo.js"); + // WebKit will actually say this URL has the string "foo.js" but is invalid. + // We don't do that. + // EXPECT_EQ(kurl7.isEmpty(), kurl7.isEmpty()); + EXPECT_FALSE(kurl7.isValid()); + EXPECT_FALSE(kurl7.string().isNull()); +} + +TEST(KURLTest, UserPass) +{ + const char* src = "http://user:pass@google.com/"; + WebCore::KURL kurl(WebCore::ParsedURLString, src); + + // Clear just the username. + kurl.setUser(""); + EXPECT_EQ("http://:pass@google.com/", kurl.string()); + + // Clear just the password. + kurl = WebCore::KURL(WebCore::ParsedURLString, src); + kurl.setPass(""); + EXPECT_EQ("http://user@google.com/", kurl.string()); + + // Now clear both. + kurl.setUser(""); + EXPECT_EQ("http://google.com/", kurl.string()); +} + +TEST(KURLTest, Offsets) +{ + const char* src1 = "http://user:pass@google.com/foo/bar.html?baz=query#ref"; + WebCore::KURL kurl1(WebCore::ParsedURLString, src1); + + EXPECT_EQ(17u, kurl1.hostStart()); + EXPECT_EQ(27u, kurl1.hostEnd()); + EXPECT_EQ(27u, kurl1.pathStart()); + EXPECT_EQ(40u, kurl1.pathEnd()); + EXPECT_EQ(32u, kurl1.pathAfterLastSlash()); + + const char* src2 = "http://google.com/foo/"; + WebCore::KURL kurl2(WebCore::ParsedURLString, src2); + + EXPECT_EQ(7u, kurl2.hostStart()); + EXPECT_EQ(17u, kurl2.hostEnd()); + EXPECT_EQ(17u, kurl2.pathStart()); + EXPECT_EQ(22u, kurl2.pathEnd()); + EXPECT_EQ(22u, kurl2.pathAfterLastSlash()); + + const char* src3 = "javascript:foobar"; + WebCore::KURL kurl3(WebCore::ParsedURLString, src3); + + EXPECT_EQ(11u, kurl3.hostStart()); + EXPECT_EQ(11u, kurl3.hostEnd()); + EXPECT_EQ(11u, kurl3.pathStart()); + EXPECT_EQ(17u, kurl3.pathEnd()); + EXPECT_EQ(11u, kurl3.pathAfterLastSlash()); +} + +TEST(KURLTest, DeepCopy) +{ + const char url[] = "http://www.google.com/"; + WebCore::KURL src(WebCore::ParsedURLString, url); + EXPECT_TRUE(src.string() == url); // This really just initializes the cache. + WebCore::KURL dest = src.copy(); + EXPECT_TRUE(dest.string() == url); // This really just initializes the cache. + + // The pointers should be different for both UTF-8 and UTF-16. + EXPECT_NE(dest.string().characters(), src.string().characters()); + EXPECT_NE(dest.utf8String().data(), src.utf8String().data()); +} + +TEST(KURLTest, ProtocolIs) +{ + WebCore::KURL url1(WebCore::ParsedURLString, "foo://bar"); + EXPECT_TRUE(url1.protocolIs("foo")); + EXPECT_FALSE(url1.protocolIs("foo-bar")); + + WebCore::KURL url2(WebCore::ParsedURLString, "foo-bar:"); + EXPECT_TRUE(url2.protocolIs("foo-bar")); + EXPECT_FALSE(url2.protocolIs("foo")); +} + +} // namespace diff --git a/WebKit/chromium/tests/KeyboardTest.cpp b/WebKit/chromium/tests/KeyboardTest.cpp new file mode 100644 index 0000000..07bed3c --- /dev/null +++ b/WebKit/chromium/tests/KeyboardTest.cpp @@ -0,0 +1,213 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <gtest/gtest.h> + +#include "EditorClientImpl.h" +#include "EventTarget.h" +#include "KeyboardCodes.h" +#include "KeyboardEvent.h" +#include "WebInputEvent.h" +#include "WebInputEventConversion.h" + +using namespace WebCore; +using namespace WebKit; + +namespace { + +class KeyboardTest : public testing::Test { +public: + + // Pass a WebKeyboardEvent into the EditorClient and get back the string + // name of which editing event that key causes. + // E.g., sending in the enter key gives back "InsertNewline". + const char* interpretKeyEvent( + const WebKeyboardEvent& webKeyboardEvent, + PlatformKeyboardEvent::Type keyType) + { + EditorClientImpl editorImpl(0); + PlatformKeyboardEventBuilder evt(webKeyboardEvent); + evt.setKeyType(keyType); + RefPtr<KeyboardEvent> keyboardEvent = KeyboardEvent::create(evt, 0); + return editorImpl.interpretKeyEvent(keyboardEvent.get()); + } + + // Set up a WebKeyboardEvent KEY_DOWN event with key code and modifiers. + void setupKeyDownEvent(WebKeyboardEvent* keyboardEvent, + char keyCode, + int modifiers) + { + keyboardEvent->windowsKeyCode = keyCode; + keyboardEvent->modifiers = modifiers; + keyboardEvent->type = WebInputEvent::KeyDown; + keyboardEvent->text[0] = keyCode; + keyboardEvent->setKeyIdentifierFromWindowsKeyCode(); + } + + // Like interpretKeyEvent, but with pressing down OSModifier+|keyCode|. + // OSModifier is the platform's standard modifier key: control on most + // platforms, but meta (command) on Mac. + const char* interpretOSModifierKeyPress(char keyCode) + { + WebKeyboardEvent keyboardEvent; +#if OS(DARWIN) + WebInputEvent::Modifiers osModifier = WebInputEvent::MetaKey; +#else + WebInputEvent::Modifiers osModifier = WebInputEvent::ControlKey; +#endif + setupKeyDownEvent(&keyboardEvent, keyCode, osModifier); + return interpretKeyEvent(keyboardEvent, PlatformKeyboardEvent::RawKeyDown); + } + + // Like interpretKeyEvent, but with pressing down ctrl+|keyCode|. + const char* interpretCtrlKeyPress(char keyCode) + { + WebKeyboardEvent keyboardEvent; + setupKeyDownEvent(&keyboardEvent, keyCode, WebInputEvent::ControlKey); + return interpretKeyEvent(keyboardEvent, PlatformKeyboardEvent::RawKeyDown); + } + + // Like interpretKeyEvent, but with typing a tab. + const char* interpretTab(int modifiers) + { + WebKeyboardEvent keyboardEvent; + setupKeyDownEvent(&keyboardEvent, '\t', modifiers); + return interpretKeyEvent(keyboardEvent, PlatformKeyboardEvent::Char); + } + + // Like interpretKeyEvent, but with typing a newline. + const char* interpretNewLine(int modifiers) + { + WebKeyboardEvent keyboardEvent; + setupKeyDownEvent(&keyboardEvent, '\r', modifiers); + return interpretKeyEvent(keyboardEvent, PlatformKeyboardEvent::Char); + } + + // A name for "no modifiers set". + static const int noModifiers = 0; +}; + +TEST_F(KeyboardTest, TestCtrlReturn) +{ + EXPECT_STREQ("InsertNewline", interpretCtrlKeyPress(0xD)); +} + +TEST_F(KeyboardTest, TestOSModifierZ) +{ +#if !OS(DARWIN) + EXPECT_STREQ("Undo", interpretOSModifierKeyPress('Z')); +#endif +} + +TEST_F(KeyboardTest, TestOSModifierY) +{ +#if !OS(DARWIN) + EXPECT_STREQ("Redo", interpretOSModifierKeyPress('Y')); +#endif +} + +TEST_F(KeyboardTest, TestOSModifierA) +{ +#if !OS(DARWIN) + EXPECT_STREQ("SelectAll", interpretOSModifierKeyPress('A')); +#endif +} + +TEST_F(KeyboardTest, TestOSModifierX) +{ +#if !OS(DARWIN) + EXPECT_STREQ("Cut", interpretOSModifierKeyPress('X')); +#endif +} + +TEST_F(KeyboardTest, TestOSModifierC) +{ +#if !OS(DARWIN) + EXPECT_STREQ("Copy", interpretOSModifierKeyPress('C')); +#endif +} + +TEST_F(KeyboardTest, TestOSModifierV) +{ +#if !OS(DARWIN) + EXPECT_STREQ("Paste", interpretOSModifierKeyPress('V')); +#endif +} + +TEST_F(KeyboardTest, TestEscape) +{ + WebKeyboardEvent keyboardEvent; + setupKeyDownEvent(&keyboardEvent, WebCore::VKEY_ESCAPE, noModifiers); + + const char* result = interpretKeyEvent(keyboardEvent, + PlatformKeyboardEvent::RawKeyDown); + EXPECT_STREQ("Cancel", result); +} + +TEST_F(KeyboardTest, TestInsertTab) +{ + EXPECT_STREQ("InsertTab", interpretTab(noModifiers)); +} + +TEST_F(KeyboardTest, TestInsertBackTab) +{ + EXPECT_STREQ("InsertBacktab", interpretTab(WebInputEvent::ShiftKey)); +} + +TEST_F(KeyboardTest, TestInsertNewline) +{ + EXPECT_STREQ("InsertNewline", interpretNewLine(noModifiers)); +} + +TEST_F(KeyboardTest, TestInsertNewline2) +{ + EXPECT_STREQ("InsertNewline", interpretNewLine(WebInputEvent::ControlKey)); +} + +TEST_F(KeyboardTest, TestInsertLineBreak) +{ + EXPECT_STREQ("InsertLineBreak", interpretNewLine(WebInputEvent::ShiftKey)); +} + +TEST_F(KeyboardTest, TestInsertNewline3) +{ + EXPECT_STREQ("InsertNewline", interpretNewLine(WebInputEvent::AltKey)); +} + +TEST_F(KeyboardTest, TestInsertNewline4) +{ + int modifiers = WebInputEvent::AltKey | WebInputEvent::ShiftKey; + const char* result = interpretNewLine(modifiers); + EXPECT_STREQ("InsertNewline", result); +} + +} // empty namespace diff --git a/WebKit/chromium/tests/RunAllTests.cpp b/WebKit/chromium/tests/RunAllTests.cpp new file mode 100644 index 0000000..0f3f82f --- /dev/null +++ b/WebKit/chromium/tests/RunAllTests.cpp @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +// FIXME: Avoid this source dependency on Chromium's base module. +#include <base/test/test_suite.h> + +#include "WebKit.h" +#include "WebKitClient.h" + +// WebKitClient has a protected destructor, so we need to subclass. +class DummyWebKitClient : public WebKit::WebKitClient { +}; + +int main(int argc, char** argv) +{ + DummyWebKitClient dummyClient; + WebKit::initialize(&dummyClient); + + int result = TestSuite(argc, argv).Run(); + + WebKit::shutdown(); + return result; +} diff --git a/WebKit/chromium/tests/TransparencyWinTest.cpp b/WebKit/chromium/tests/TransparencyWinTest.cpp new file mode 100644 index 0000000..b83c2a9 --- /dev/null +++ b/WebKit/chromium/tests/TransparencyWinTest.cpp @@ -0,0 +1,693 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "TransparencyWin.h" + +#include "AffineTransform.h" +#include "ImageBuffer.h" + +#include <gtest/gtest.h> +#include <windows.h> + +namespace WebCore { + +static FloatRect RECTToFloatRect(const RECT* rect) +{ + return FloatRect(static_cast<float>(rect->left), + static_cast<float>(rect->top), + static_cast<float>(rect->right - rect->left), + static_cast<float>(rect->bottom - rect->top)); +} + +static void drawNativeRect(GraphicsContext* context, + int x, int y, int w, int h) +{ + skia::PlatformCanvas* canvas = context->platformContext()->canvas(); + HDC dc = canvas->beginPlatformPaint(); + + RECT innerRc; + innerRc.left = x; + innerRc.top = y; + innerRc.right = x + w; + innerRc.bottom = y + h; + FillRect(dc, &innerRc, + reinterpret_cast<HBRUSH>(GetStockObject(BLACK_BRUSH))); + + canvas->endPlatformPaint(); +} + +static Color getPixelAt(GraphicsContext* context, int x, int y) +{ + const SkBitmap& bitmap = context->platformContext()->canvas()-> + getTopPlatformDevice().accessBitmap(false); + return Color(*reinterpret_cast<const RGBA32*>(bitmap.getAddr32(x, y))); +} + +// Resets the top layer's alpha channel to 0 for each pixel. This simulates +// Windows messing it up. +static void clearTopLayerAlphaChannel(GraphicsContext* context) +{ + SkBitmap& bitmap = const_cast<SkBitmap&>(context->platformContext()-> + canvas()->getTopPlatformDevice().accessBitmap(false)); + for (int y = 0; y < bitmap.height(); y++) { + uint32_t* row = bitmap.getAddr32(0, y); + for (int x = 0; x < bitmap.width(); x++) + row[x] &= 0x00FFFFFF; + } +} + +// Clears the alpha channel on the specified pixel. +static void clearTopLayerAlphaPixel(GraphicsContext* context, int x, int y) +{ + SkBitmap& bitmap = const_cast<SkBitmap&>(context->platformContext()-> + canvas()->getTopPlatformDevice().accessBitmap(false)); + *bitmap.getAddr32(x, y) &= 0x00FFFFFF; +} + +static std::ostream& operator<<(std::ostream& out, const Color& c) +{ + std::ios_base::fmtflags oldFlags = out.flags(std::ios_base::hex | + std::ios_base::showbase); + out << c.rgb(); + out.flags(oldFlags); + return out; +} + +TEST(TransparencyWin, NoLayer) +{ + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(17, 16), DeviceRGB)); + + // KeepTransform + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::NoLayer, + TransparencyWin::KeepTransform, + IntRect(1, 1, 14, 12)); + + EXPECT_TRUE(src->context() == helper.context()); + EXPECT_TRUE(IntSize(14, 12) == helper.m_layerSize); + EXPECT_TRUE(IntRect(1, 1, 14, 12) == helper.drawRect()); + } + + // Untransform is not allowed for NoLayer. + + // ScaleTransform + src->context()->save(); + src->context()->scale(FloatSize(2.0, 0.5)); + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::NoLayer, + TransparencyWin::ScaleTransform, + IntRect(2, 2, 6, 6)); + helper.composite(); + + // The coordinate system should be based in the upper left of our box. + // It should be post-transformed. + EXPECT_TRUE(src->context() == helper.context()); + EXPECT_TRUE(IntSize(12, 3) == helper.m_layerSize); + EXPECT_TRUE(IntRect(4, 1, 12, 3) == helper.drawRect()); + } + src->context()->restore(); +} + +TEST(TransparencyWin, WhiteLayer) +{ + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + + // KeepTransform + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::WhiteLayer, + TransparencyWin::KeepTransform, + IntRect(1, 1, 14, 12)); + helper.composite(); + + EXPECT_TRUE(src->context() != helper.context()); + EXPECT_TRUE(IntSize(14, 12) == helper.m_layerSize); + EXPECT_TRUE(IntRect(1, 1, 14, 12) == helper.drawRect()); + } + + // Untransform + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::WhiteLayer, + TransparencyWin::Untransform, + IntRect(1, 1, 14, 12)); + helper.composite(); + + EXPECT_TRUE(src->context() != helper.context()); + EXPECT_TRUE(IntSize(14, 12) == helper.m_layerSize); + EXPECT_TRUE(IntRect(0, 0, 14, 12) == helper.drawRect()); + } + + // ScaleTransform + src->context()->save(); + src->context()->scale(FloatSize(2.0, 0.5)); + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::WhiteLayer, + TransparencyWin::ScaleTransform, + IntRect(2, 2, 6, 6)); + helper.composite(); + + // The coordinate system should be based in the upper left of our box. + // It should be post-transformed. + EXPECT_TRUE(src->context() != helper.context()); + EXPECT_TRUE(IntSize(12, 3) == helper.m_layerSize); + EXPECT_TRUE(IntRect(0, 0, 12, 3) == helper.drawRect()); + } + src->context()->restore(); +} + +TEST(TransparencyWin, TextComposite) +{ + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + + // KeepTransform is the only valid transform mode for TextComposite. + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::TextComposite, + TransparencyWin::KeepTransform, + IntRect(1, 1, 14, 12)); + helper.composite(); + + EXPECT_TRUE(src->context() != helper.context()); + EXPECT_TRUE(IntSize(14, 12) == helper.m_layerSize); + EXPECT_TRUE(IntRect(1, 1, 14, 12) == helper.drawRect()); + } +} + +TEST(TransparencyWin, OpaqueCompositeLayer) +{ + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + + // KeepTransform + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::OpaqueCompositeLayer, + TransparencyWin::KeepTransform, + IntRect(1, 1, 14, 12)); + helper.composite(); + + EXPECT_TRUE(src->context() != helper.context()); + EXPECT_TRUE(IntSize(14, 12) == helper.m_layerSize); + EXPECT_TRUE(IntRect(1, 1, 14, 12) == helper.drawRect()); + } + + // KeepTransform with scroll applied. + src->context()->save(); + src->context()->translate(0, -1); + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::OpaqueCompositeLayer, + TransparencyWin::KeepTransform, + IntRect(1, 1, 14, 14)); + helper.composite(); + + EXPECT_TRUE(src->context() != helper.context()); + EXPECT_TRUE(IntSize(14, 14) == helper.m_layerSize); + EXPECT_TRUE(IntRect(1, 1, 14, 14) == helper.drawRect()); + } + src->context()->restore(); + + // Untransform + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::OpaqueCompositeLayer, + TransparencyWin::Untransform, + IntRect(1, 1, 14, 12)); + helper.composite(); + + EXPECT_TRUE(src->context() != helper.context()); + EXPECT_TRUE(IntSize(14, 12) == helper.m_layerSize); + EXPECT_TRUE(IntRect(0, 0, 14, 12) == helper.drawRect()); + } + + // ScaleTransform + src->context()->save(); + src->context()->scale(FloatSize(2.0, 0.5)); + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::OpaqueCompositeLayer, + TransparencyWin::ScaleTransform, + IntRect(2, 2, 6, 6)); + helper.composite(); + + // The coordinate system should be based in the upper left of our box. + // It should be post-transformed. + EXPECT_TRUE(src->context() != helper.context()); + EXPECT_TRUE(IntSize(12, 3) == helper.m_layerSize); + EXPECT_TRUE(IntRect(0, 0, 12, 3) == helper.drawRect()); + } + src->context()->restore(); +} + +TEST(TransparencyWin, WhiteLayerPixelTest) +{ + // Make a total transparent buffer, and draw the white layer inset by 1 px. + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::WhiteLayer, + TransparencyWin::KeepTransform, + IntRect(1, 1, 14, 14)); + + // Coordinates should be in the original space, not the layer. + drawNativeRect(helper.context(), 3, 3, 1, 1); + clearTopLayerAlphaChannel(helper.context()); + helper.composite(); + } + + // The final image should be transparent around the edges for 1 px, white + // in the middle, with (3,3) (what we drew above) being opaque black. + EXPECT_EQ(Color(Color::transparent), getPixelAt(src->context(), 0, 0)); + EXPECT_EQ(Color(Color::white), getPixelAt(src->context(), 2, 2)); + EXPECT_EQ(Color(Color::black), getPixelAt(src->context(), 3, 3)); + EXPECT_EQ(Color(Color::white), getPixelAt(src->context(), 4, 4)); +} + +TEST(TransparencyWin, OpaqueCompositeLayerPixel) +{ + Color red(0xFFFF0000), darkRed(0xFFBF0000); + Color green(0xFF00FF00); + + // Make a red bottom layer, followed by a half green next layer @ 50%. + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + + FloatRect fullRect(0, 0, 16, 16); + src->context()->fillRect(fullRect, red, DeviceColorSpace); + src->context()->beginTransparencyLayer(0.5); + FloatRect rightHalf(8, 0, 8, 16); + src->context()->fillRect(rightHalf, green, DeviceColorSpace); + + // Make a transparency layer inset by one pixel, and fill it inset by + // another pixel with 50% black. + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::OpaqueCompositeLayer, + TransparencyWin::KeepTransform, + IntRect(1, 1, 14, 14)); + + FloatRect inner(2, 2, 12, 12); + helper.context()->fillRect(inner, Color(0x7f000000), DeviceColorSpace); + // These coordinates are relative to the layer, whish is inset by 1x1 + // pixels from the top left. So we're actually clearing (2, 2) and + // (13,13), which are the extreme corners of the black area (and which + // we check below). + clearTopLayerAlphaPixel(helper.context(), 1, 1); + clearTopLayerAlphaPixel(helper.context(), 12, 12); + helper.composite(); + } + + // Finish the compositing. + src->context()->endTransparencyLayer(); + + // Check that we got the right values, it should be like the rectangle was + // drawn with half opacity even though the alpha channel got messed up. + EXPECT_EQ(red, getPixelAt(src->context(), 0, 0)); + EXPECT_EQ(red, getPixelAt(src->context(), 1, 1)); + EXPECT_EQ(darkRed, getPixelAt(src->context(), 2, 2)); + + // The dark result is: + // (black @ 50% atop green) @ 50% atop red = 0xFF804000 + // which is 0xFFA02000 (Skia computes 0xFFA11F00 due to rounding). + Color darkGreenRed(0xFF803f00); + EXPECT_EQ(darkGreenRed, getPixelAt(src->context(), 13, 13)); + + // 50% green on top of red = FF808000 (rounded to what Skia will produce). + Color greenRed(0xFF807F00); + EXPECT_EQ(greenRed, getPixelAt(src->context(), 14, 14)); + EXPECT_EQ(greenRed, getPixelAt(src->context(), 15, 15)); +} + +// Tests that translations are properly handled when using KeepTransform. +TEST(TransparencyWin, TranslateOpaqueCompositeLayer) +{ + // Fill with white. + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + Color white(0xFFFFFFFF); + FloatRect fullRect(0, 0, 16, 16); + src->context()->fillRect(fullRect, white, DeviceColorSpace); + + // Scroll down by 8 (coordinate system goes up). + src->context()->save(); + src->context()->translate(0, -8); + + Color red(0xFFFF0000); + Color green(0xFF00FF00); + { + // Make the transparency layer after translation will be @ (0, -8) with + // size 16x16. + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::OpaqueCompositeLayer, + TransparencyWin::KeepTransform, + IntRect(0, 0, 16, 16)); + + // Draw a red pixel at (15, 15). This should be the at (15, 7) after + // the transform. + FloatRect bottomRight(15, 15, 1, 1); + helper.context()->fillRect(bottomRight, green, DeviceColorSpace); + helper.composite(); + } + + src->context()->restore(); + + // Check the pixel we wrote. + EXPECT_EQ(green, getPixelAt(src->context(), 15, 7)); +} + +// Same as OpaqueCompositeLayer, but the canvas has a rotation applied. This +// tests that the propert transform is applied to the copied layer. +TEST(TransparencyWin, RotateOpaqueCompositeLayer) +{ + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + + // The background is white. + Color white(0xFFFFFFFF); + FloatRect fullRect(0, 0, 16, 16); + src->context()->fillRect(fullRect, white, DeviceColorSpace); + + // Rotate the image by 90 degrees. This matrix is the same as + // cw90.rotate(90); but avoids rounding errors. Rounding errors can cause + // Skia to think that !rectStaysRect() and it will fall through to path + // drawing mode, which in turn gives us antialiasing. We want no + // antialiasing or other rounding problems since we're testing exact pixel + // values. + src->context()->save(); + AffineTransform cw90(0, 1, -1, 0, 0, 0); + src->context()->concatCTM(cw90); + + // Make a transparency layer consisting of a horizontal line of 50% black. + // Since the rotation is applied, this will actually be a vertical line + // down the middle of the image. + src->context()->beginTransparencyLayer(0.5); + FloatRect blackRect(0, -9, 16, 2); + Color black(0xFF000000); + src->context()->fillRect(blackRect, black, DeviceColorSpace); + + // Now draw 50% red square. + { + // Create a transparency helper inset one pixel in the buffer. The + // coordinates are before transforming into this space, and maps to + // IntRect(1, 1, 14, 14). + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::OpaqueCompositeLayer, + TransparencyWin::Untransform, + IntRect(1, -15, 14, 14)); + + // Fill with red. + helper.context()->fillRect(helper.drawRect(), Color(0x7f7f0000), DeviceColorSpace); + clearTopLayerAlphaChannel(helper.context()); + helper.composite(); + } + + // Finish the compositing. + src->context()->endTransparencyLayer(); + + // Top corner should be the original background. + EXPECT_EQ(white, getPixelAt(src->context(), 0, 0)); + + // Check the stripe down the middle, first at the top... + Color gray(0xFF808080); + EXPECT_EQ(white, getPixelAt(src->context(), 6, 0)); + EXPECT_EQ(gray, getPixelAt(src->context(), 7, 0)); + EXPECT_EQ(gray, getPixelAt(src->context(), 8, 0)); + EXPECT_EQ(white, getPixelAt(src->context(), 9, 0)); + + // ...now at the bottom. + EXPECT_EQ(white, getPixelAt(src->context(), 6, 15)); + EXPECT_EQ(gray, getPixelAt(src->context(), 7, 15)); + EXPECT_EQ(gray, getPixelAt(src->context(), 8, 15)); + EXPECT_EQ(white, getPixelAt(src->context(), 9, 15)); + + // Our red square should be 25% red over the top of those two. + Color redwhite(0xFFdfbfbf); + Color redgray(0xFF9f8080); + EXPECT_EQ(white, getPixelAt(src->context(), 0, 1)); + EXPECT_EQ(redwhite, getPixelAt(src->context(), 1, 1)); + EXPECT_EQ(redwhite, getPixelAt(src->context(), 6, 1)); + EXPECT_EQ(redgray, getPixelAt(src->context(), 7, 1)); + EXPECT_EQ(redgray, getPixelAt(src->context(), 8, 1)); + EXPECT_EQ(redwhite, getPixelAt(src->context(), 9, 1)); + EXPECT_EQ(redwhite, getPixelAt(src->context(), 14, 1)); + EXPECT_EQ(white, getPixelAt(src->context(), 15, 1)); + + // Complete the 50% transparent layer. + src->context()->restore(); +} + +TEST(TransparencyWin, TranslateScaleOpaqueCompositeLayer) +{ + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + + // The background is white on top with red on bottom. + Color white(0xFFFFFFFF); + FloatRect topRect(0, 0, 16, 8); + src->context()->fillRect(topRect, white, DeviceColorSpace); + Color red(0xFFFF0000); + FloatRect bottomRect(0, 8, 16, 8); + src->context()->fillRect(bottomRect, red, DeviceColorSpace); + + src->context()->save(); + + // Translate left by one pixel. + AffineTransform left; + left.translate(-1, 0); + + // Scale by 2x. + AffineTransform scale; + scale.scale(2.0); + src->context()->concatCTM(scale); + + // Then translate up by one pixel (which will actually be 2 due to scaling). + AffineTransform up; + up.translate(0, -1); + src->context()->concatCTM(up); + + // Now draw 50% red square. + { + // Create a transparency helper inset one pixel in the buffer. The + // coordinates are before transforming into this space, and maps to + // IntRect(1, 1, 14, 14). + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::OpaqueCompositeLayer, + TransparencyWin::KeepTransform, + IntRect(1, -15, 14, 14)); + + // Fill with red. + helper.context()->fillRect(helper.drawRect(), Color(0x7f7f0000), DeviceColorSpace); + clearTopLayerAlphaChannel(helper.context()); + helper.composite(); + } +} + +// Tests scale mode with no additional copy. +TEST(TransparencyWin, Scale) +{ + // Create an opaque white buffer. + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + FloatRect fullBuffer(0, 0, 16, 16); + src->context()->fillRect(fullBuffer, Color::white, DeviceColorSpace); + + // Scale by 2x. + src->context()->save(); + AffineTransform scale; + scale.scale(2.0); + src->context()->concatCTM(scale); + + // Start drawing a rectangle from 1->4. This should get scaled to 2->8. + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::NoLayer, + TransparencyWin::ScaleTransform, + IntRect(1, 1, 3, 3)); + + // The context should now have the identity transform and the returned + // rect should be scaled. + EXPECT_TRUE(helper.context()->getCTM().isIdentity()); + EXPECT_EQ(2, helper.drawRect().x()); + EXPECT_EQ(2, helper.drawRect().y()); + EXPECT_EQ(8, helper.drawRect().right()); + EXPECT_EQ(8, helper.drawRect().bottom()); + + // Set the pixel at (2, 2) to be transparent. This should be fixed when + // the helper goes out of scope. We don't want to call + // clearTopLayerAlphaChannel because that will actually clear the whole + // canvas (since we have no extra layer!). + SkBitmap& bitmap = const_cast<SkBitmap&>(helper.context()-> + platformContext()->canvas()->getTopPlatformDevice(). + accessBitmap(false)); + *bitmap.getAddr32(2, 2) &= 0x00FFFFFF; + helper.composite(); + } + + src->context()->restore(); + + // Check the pixel we previously made transparent, it should have gotten + // fixed back up to white. + + // The current version doesn't fixup transparency when there is no layer. + // This seems not to be necessary, so we don't bother, but if it becomes + // necessary, this line should be uncommented. + // EXPECT_EQ(Color(Color::white), getPixelAt(src->context(), 2, 2)); +} + +// Tests scale mode with an additional copy for transparency. This will happen +// if we have a scaled textbox, for example. WebKit will create a new +// transparency layer, draw the text field, then draw the text into it, then +// composite this down with an opacity. +TEST(TransparencyWin, ScaleTransparency) +{ + // Create an opaque white buffer. + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + FloatRect fullBuffer(0, 0, 16, 16); + src->context()->fillRect(fullBuffer, Color::white, DeviceColorSpace); + + // Make another layer (which duplicates how WebKit will make this). We fill + // the top half with red, and have the layer be 50% opaque. + src->context()->beginTransparencyLayer(0.5); + FloatRect topHalf(0, 0, 16, 8); + src->context()->fillRect(topHalf, Color(0xFFFF0000), DeviceColorSpace); + + // Scale by 2x. + src->context()->save(); + AffineTransform scale; + scale.scale(2.0); + src->context()->concatCTM(scale); + + // Make a layer inset two pixels (because of scaling, this is 2->14). And + // will it with 50% black. + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::OpaqueCompositeLayer, + TransparencyWin::ScaleTransform, + IntRect(1, 1, 6, 6)); + + helper.context()->fillRect(helper.drawRect(), Color(0x7f000000), DeviceColorSpace); + clearTopLayerAlphaChannel(helper.context()); + helper.composite(); + } + + // Finish the layer. + src->context()->restore(); + src->context()->endTransparencyLayer(); + + Color redBackground(0xFFFF8080); // 50% red composited on white. + EXPECT_EQ(redBackground, getPixelAt(src->context(), 0, 0)); + EXPECT_EQ(redBackground, getPixelAt(src->context(), 1, 1)); + + // Top half (minus two pixel border) should be 50% gray atop opaque + // red = 0xFF804141. Then that's composited with 50% transparency on solid + // white = 0xFFC0A1A1. + Color darkRed(0xFFBF8080); + EXPECT_EQ(darkRed, getPixelAt(src->context(), 2, 2)); + EXPECT_EQ(darkRed, getPixelAt(src->context(), 7, 7)); + + // Bottom half (minus a two pixel border) should be a layer with 5% gray + // with another 50% opacity composited atop white. + Color darkWhite(0xFFBFBFBF); + EXPECT_EQ(darkWhite, getPixelAt(src->context(), 8, 8)); + EXPECT_EQ(darkWhite, getPixelAt(src->context(), 13, 13)); + + Color white(0xFFFFFFFF); // Background in the lower-right. + EXPECT_EQ(white, getPixelAt(src->context(), 14, 14)); + EXPECT_EQ(white, getPixelAt(src->context(), 15, 15)); +} + +TEST(TransparencyWin, Text) +{ + OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); + + // Our text should end up 50% transparent blue-green. + Color fullResult(0x80008080); + + { + TransparencyWin helper; + helper.init(src->context(), + TransparencyWin::TextComposite, + TransparencyWin::KeepTransform, + IntRect(0, 0, 16, 16)); + helper.setTextCompositeColor(fullResult); + + // Write several different squares to simulate ClearType. These should + // all reduce to 2/3 coverage. + FloatRect pixel(0, 0, 1, 1); + helper.context()->fillRect(pixel, 0xFFFF0000, DeviceColorSpace); + pixel.move(1.0f, 0.0f); + helper.context()->fillRect(pixel, 0xFF00FF00, DeviceColorSpace); + pixel.move(1.0f, 0.0f); + helper.context()->fillRect(pixel, 0xFF0000FF, DeviceColorSpace); + pixel.move(1.0f, 0.0f); + helper.context()->fillRect(pixel, 0xFF008080, DeviceColorSpace); + pixel.move(1.0f, 0.0f); + helper.context()->fillRect(pixel, 0xFF800080, DeviceColorSpace); + pixel.move(1.0f, 0.0f); + helper.context()->fillRect(pixel, 0xFF808000, DeviceColorSpace); + + // Try one with 100% coverage (opaque black). + pixel.move(1.0f, 0.0f); + helper.context()->fillRect(pixel, 0xFF000000, DeviceColorSpace); + + // Now mess with the alpha channel. + clearTopLayerAlphaChannel(helper.context()); + helper.composite(); + } + + Color oneThirdResult(0x55005555); // = fullResult * 2 / 3 + EXPECT_EQ(oneThirdResult, getPixelAt(src->context(), 0, 0)); + EXPECT_EQ(oneThirdResult, getPixelAt(src->context(), 1, 0)); + EXPECT_EQ(oneThirdResult, getPixelAt(src->context(), 2, 0)); + EXPECT_EQ(oneThirdResult, getPixelAt(src->context(), 3, 0)); + EXPECT_EQ(oneThirdResult, getPixelAt(src->context(), 4, 0)); + EXPECT_EQ(oneThirdResult, getPixelAt(src->context(), 5, 0)); + EXPECT_EQ(fullResult, getPixelAt(src->context(), 6, 0)); + EXPECT_EQ(Color::transparent, getPixelAt(src->context(), 7, 0)); +} + +} // namespace WebCore diff --git a/WebKit/chromium/tests/UniscribeHelperTest.cpp b/WebKit/chromium/tests/UniscribeHelperTest.cpp new file mode 100644 index 0000000..8aaed11 --- /dev/null +++ b/WebKit/chromium/tests/UniscribeHelperTest.cpp @@ -0,0 +1,165 @@ +/* + * Copyright (C) 2010 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <gtest/gtest.h> + +#include "PlatformString.h" +#include "UniscribeHelper.h" + +using namespace WebCore; + +namespace { + +class UniscribeTest : public testing::Test { +public: + UniscribeTest() + { + } + + // Returns an HFONT with the given name. The caller does not have to free + // this, it will be automatically freed at the end of the test. Returns 0 + // on failure. On success, the + HFONT MakeFont(const wchar_t* fontName, SCRIPT_CACHE** cache) + { + LOGFONT lf; + memset(&lf, 0, sizeof(LOGFONT)); + lf.lfHeight = 20; + wcscpy_s(lf.lfFaceName, fontName); + + HFONT hfont = CreateFontIndirect(&lf); + if (!hfont) + return 0; + + *cache = new SCRIPT_CACHE; + **cache = 0; + createdFonts.append(std::make_pair(hfont, *cache)); + return hfont; + } + +protected: + // Default font properties structure for tests to use. + SCRIPT_FONTPROPERTIES properties; + +private: + virtual void SetUp() + { + memset(&properties, 0, sizeof(SCRIPT_FONTPROPERTIES)); + properties.cBytes = sizeof(SCRIPT_FONTPROPERTIES); + properties.wgBlank = ' '; + properties.wgDefault = '?'; // Used when the char is not in the font. + properties.wgInvalid = '#'; // Used for invalid characters. + } + + virtual void TearDown() + { + // Free any allocated fonts. + for (size_t i = 0; i < createdFonts.size(); i++) { + DeleteObject(createdFonts[i].first); + ScriptFreeCache(createdFonts[i].second); + delete createdFonts[i].second; + } + createdFonts.clear(); + } + + // Tracks allocated fonts so we can delete them at the end of the test. + // The script cache pointer is heap allocated and must be freed. + Vector< std::pair<HFONT, SCRIPT_CACHE*> > createdFonts; +}; + +} // namespace + +// This test tests giving Uniscribe a very large buffer, which will cause a +// failure. +TEST_F(UniscribeTest, TooBig) +{ + // Make a large string with an e with a zillion combining accents. + String input(L"e"); + for (int i = 0; i < 100000; i++) + input.append(static_cast<UChar>(0x301)); // Combining acute accent. + + SCRIPT_CACHE* scriptCache; + HFONT hfont = MakeFont(L"Times New Roman", &scriptCache); + ASSERT_TRUE(hfont); + + // Test a long string without the normal length protection we have. This + // will cause shaping to fail. + { + UniscribeHelper uniscribe( + input.characters(), static_cast<int>(input.length()), + false, hfont, scriptCache, &properties); + uniscribe.initWithOptionalLengthProtection(false); + + // There should be one shaping entry, with nothing in it. + ASSERT_EQ(1, uniscribe.m_shapes.size()); + EXPECT_EQ(0, uniscribe.m_shapes[0].m_glyphs.size()); + EXPECT_EQ(0, uniscribe.m_shapes[0].m_logs.size()); + EXPECT_EQ(0, uniscribe.m_shapes[0].m_visualAttributes.size()); + EXPECT_EQ(0, uniscribe.m_shapes[0].m_advance.size()); + EXPECT_EQ(0, uniscribe.m_shapes[0].m_offsets.size()); + EXPECT_EQ(0, uniscribe.m_shapes[0].m_justify.size()); + EXPECT_EQ(0, uniscribe.m_shapes[0].m_abc.abcA); + EXPECT_EQ(0, uniscribe.m_shapes[0].m_abc.abcB); + EXPECT_EQ(0, uniscribe.m_shapes[0].m_abc.abcC); + + // The sizes of the other stuff should match the shaping entry. + EXPECT_EQ(1, uniscribe.m_runs.size()); + EXPECT_EQ(1, uniscribe.m_screenOrder.size()); + + // Check that the various querying functions handle the empty case + // properly. + EXPECT_EQ(0, uniscribe.width()); + EXPECT_EQ(0, uniscribe.firstGlyphForCharacter(0)); + EXPECT_EQ(0, uniscribe.firstGlyphForCharacter(1000)); + EXPECT_EQ(0, uniscribe.xToCharacter(0)); + EXPECT_EQ(0, uniscribe.xToCharacter(1000)); + } + + // Now test the very large string and make sure it is handled properly by + // the length protection. + { + UniscribeHelper uniscribe( + input.characters(), static_cast<int>(input.length()), + false, hfont, scriptCache, &properties); + uniscribe.initWithOptionalLengthProtection(true); + + // There should be 0 runs and shapes. + EXPECT_EQ(0, uniscribe.m_runs.size()); + EXPECT_EQ(0, uniscribe.m_shapes.size()); + EXPECT_EQ(0, uniscribe.m_screenOrder.size()); + + EXPECT_EQ(0, uniscribe.width()); + EXPECT_EQ(0, uniscribe.firstGlyphForCharacter(0)); + EXPECT_EQ(0, uniscribe.firstGlyphForCharacter(1000)); + EXPECT_EQ(0, uniscribe.xToCharacter(0)); + EXPECT_EQ(0, uniscribe.xToCharacter(1000)); + } +} |
