More WEBCORE_EXPORT macros!
authorachristensen@apple.com <achristensen@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 22 Aug 2014 04:21:18 +0000 (04:21 +0000)
committerachristensen@apple.com <achristensen@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 22 Aug 2014 04:21:18 +0000 (04:21 +0000)
https://bugs.webkit.org/show_bug.cgi?id=136146

Reviewed by Benjamin Poulain.

* Modules/geolocation/GeolocationClient.h:
* Modules/mediastream/UserMediaClient.h:
* Modules/mediastream/UserMediaRequest.h:
* Modules/notifications/NotificationClient.h:
* Modules/speech/SpeechSynthesis.h:
* bindings/generic/RuntimeEnabledFeatures.h:
* bindings/js/DOMWrapperWorld.h:
* bindings/js/GCController.h:
* bindings/js/IDBBindingUtilities.h:
* bindings/js/JSDOMBinding.h:
* bindings/js/JSNodeCustom.h:
* bindings/js/JSNodeListCustom.h:
* bindings/js/JSPluginElementFunctions.h:
* bindings/js/ScriptController.h:
* bindings/js/SerializedScriptValue.h:
* crypto/SerializedCryptoKeyWrap.h:
* css/LengthFunctions.h:
* css/StyleProperties.h:
* css/StyleSheetContents.h:
* dom/DeviceOrientationClient.h:
* dom/Range.h:
* dom/ScriptExecutionContext.h:
* dom/StyledElement.h:
* dom/TreeScope.h:
* dom/UIEventWithKeyState.h:
* dom/UserGestureIndicator.h:
* dom/UserTypingGestureIndicator.h:
* dom/ViewportArguments.h:
* editing/SmartReplace.h:
* editing/TextIterator.h:
* editing/VisiblePosition.h:
* editing/VisibleSelection.h:
* editing/VisibleUnits.h:
* editing/cocoa/HTMLConverter.h:
* editing/htmlediting.h:
* editing/mac/TextAlternativeWithRange.h:
* editing/mac/TextUndoInsertionMarkupMac.h:
* editing/markup.h:
* history/HistoryItem.cpp:
* history/PageCache.h:
* html/TimeRanges.h:
* html/parser/HTMLParserIdioms.h:
* inspector/InstrumentingAgents.h:
* loader/FrameLoader.h:
* loader/ResourceBuffer.h:
* loader/ResourceLoadScheduler.h:
* loader/ResourceLoader.h:
(WebCore::ResourceLoader::originalRequest):
* loader/SubframeLoader.h:
* loader/SubresourceLoader.h:
* loader/TextResourceDecoder.h:
* loader/appcache/ApplicationCacheStorage.h:
* loader/cache/MemoryCache.h:
* loader/icon/IconDatabaseBase.h:
* loader/ios/DiskImageCacheIOS.h:
* page/Chrome.h:
* page/SecurityOrigin.h:
* page/SecurityPolicy.h:
* page/Settings.h:
* page/UserContentController.h:
* page/UserContentURLPattern.h:
* page/UserMessageHandlerDescriptor.h:
* page/ViewportConfiguration.h:
* page/VisitedLinkStore.h:
* page/WheelEventDeltaTracker.h:
* page/cocoa/UserAgent.h:
* page/scrolling/ScrollingConstraints.h:
* page/scrolling/ScrollingCoordinator.h:
* page/scrolling/ScrollingStateFixedNode.h:
* page/scrolling/ScrollingStateFrameScrollingNode.h:
* page/scrolling/ScrollingStateNode.h:
* page/scrolling/ScrollingStateOverflowScrollingNode.h:
* page/scrolling/ScrollingStateScrollingNode.h:
* page/scrolling/ScrollingStateStickyNode.h:
* page/scrolling/ScrollingStateTree.h:
* page/scrolling/ScrollingThread.h:
* page/scrolling/ScrollingTree.h:
* page/scrolling/ScrollingTreeOverflowScrollingNode.h:
* page/scrolling/ScrollingTreeScrollingNode.h:
* page/scrolling/ios/ScrollingTreeFrameScrollingNodeIOS.h:
* page/scrolling/mac/ScrollingTreeFixedNode.h:
* page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.h:
* page/scrolling/mac/ScrollingTreeStickyNode.h:
* platform/Cursor.h:
* platform/DragImage.h:
* platform/FileSystem.h:
* platform/Language.h:
* platform/LinkHash.h:
* platform/LocalizedStrings.h:
* platform/Logging.h:
* platform/MemoryPressureHandler.h:
* platform/NotImplemented.h:
* platform/PlatformStrategies.h:
* platform/PublicSuffix.h:
* platform/RuntimeApplicationChecks.h:
* platform/RuntimeApplicationChecksIOS.h:
* platform/SchemeRegistry.h:
* platform/ScrollView.h:
* platform/ScrollableArea.h:
* platform/Scrollbar.h:
* platform/ScrollbarTheme.h:
* platform/SharedBuffer.h:
* platform/ThreadCheck.h:
* platform/ThreadGlobalData.h:
* platform/Timer.h:
* platform/URL.h:
* platform/UUID.h:
* platform/UserActivity.h:
* platform/Widget.h:
* platform/cf/CFURLExtras.h:
* platform/cf/RunLoopObserver.h:
* platform/cocoa/SystemVersion.h:
* platform/graphics/Color.h:
* platform/graphics/FloatRect.h:
* platform/graphics/FontCache.h:
* platform/graphics/GeometryUtilities.h:
* platform/graphics/GraphicsContext.h:
* platform/graphics/IntRect.h:
* platform/graphics/LayoutRect.h:
* platform/graphics/StringTruncator.h:
* platform/graphics/TextRun.h:
* platform/graphics/ca/TileController.h:
* platform/graphics/ca/mac/PlatformCAAnimationMac.h:
* platform/graphics/cg/GraphicsContextCG.h:
* platform/graphics/mac/ColorMac.h:
* platform/graphics/transforms/TransformationMatrix.h:
* platform/ios/FileSystemIOS.h:
* platform/ios/PlatformEventFactoryIOS.h:
* platform/ios/SelectionRect.h:
* platform/ios/SystemMemory.h:
* platform/ios/TileControllerMemoryHandlerIOS.h:
* platform/ios/WebVideoFullscreenInterfaceAVKit.h:
* platform/mac/PlatformEventFactoryMac.h:
* platform/mac/ScrollbarThemeMac.h:
* platform/mac/WebCoreNSURLExtras.h:
* platform/mac/WebNSAttributedStringExtras.h:
* platform/network/BlobRegistry.h:
* platform/network/CookieStorage.h:
* platform/network/DNS.h:
* platform/network/NetworkStateNotifier.h:
* platform/network/PlatformCookieJar.h:
* platform/network/ProxyServer.h:
* platform/network/ResourceErrorBase.h:
* platform/network/ResourceHandle.h:
* platform/network/ResourceHandleClient.h:
* platform/network/ResourceRequestBase.h:
* platform/network/ResourceResponseBase.h:
* platform/network/SynchronousLoaderClient.h:
* platform/network/cf/ResourceError.h:
* platform/network/cf/ResourceRequest.h:
* platform/network/cf/ResourceResponse.h:
* platform/network/ios/QuickLook.h:
* platform/network/mac/AuthenticationMac.h:
* platform/sql/SQLiteDatabase.cpp:
* platform/text/LocaleToScriptMapping.h:
* platform/text/TextBreakIterator.h:
* platform/text/TextEncoding.h:
(WebCore::TextEncoding::decode):
* platform/text/TextEncodingRegistry.h:
* platform/text/TextStream.h:
* rendering/RenderBlock.h:
* rendering/RenderBox.h:
* rendering/RenderEmbeddedObject.h:
* rendering/RenderLayer.h:
* rendering/RenderLayerBacking.h:
* rendering/RenderLayerCompositor.h:
* rendering/RenderListItem.h:
* rendering/RenderObject.h:
* rendering/RenderText.h:
* rendering/RenderTextControl.h:
* rendering/RenderThemeIOS.h:
* rendering/RenderTreeAsText.h:
* rendering/RenderView.h:
* rendering/RenderWidget.h:
* rendering/ScrollBehavior.cpp:
* rendering/break_lines.cpp:
* rendering/style/RenderStyle.h:
* replay/UserInputBridge.h:
* storage/StorageEventDispatcher.h:
* storage/StorageMap.h:
* storage/StorageStrategy.h:
* storage/StorageTracker.h:
* testing/Internals.h:
* workers/WorkerThread.h:
Added more WEBCORE_EXPORT macros where needed.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@172849 268f45cc-cd09-0410-ab3c-d52691b4dbfc

183 files changed:
Source/WebCore/ChangeLog
Source/WebCore/Modules/geolocation/GeolocationClient.h
Source/WebCore/Modules/mediastream/UserMediaClient.h
Source/WebCore/Modules/mediastream/UserMediaRequest.h
Source/WebCore/Modules/notifications/NotificationClient.h
Source/WebCore/Modules/speech/SpeechSynthesis.h
Source/WebCore/bindings/generic/RuntimeEnabledFeatures.h
Source/WebCore/bindings/js/DOMWrapperWorld.h
Source/WebCore/bindings/js/GCController.h
Source/WebCore/bindings/js/IDBBindingUtilities.h
Source/WebCore/bindings/js/JSDOMBinding.h
Source/WebCore/bindings/js/JSNodeCustom.h
Source/WebCore/bindings/js/JSNodeListCustom.h
Source/WebCore/bindings/js/JSPluginElementFunctions.h
Source/WebCore/bindings/js/ScriptController.h
Source/WebCore/bindings/js/SerializedScriptValue.h
Source/WebCore/crypto/SerializedCryptoKeyWrap.h
Source/WebCore/css/LengthFunctions.h
Source/WebCore/css/StyleProperties.h
Source/WebCore/css/StyleSheetContents.h
Source/WebCore/dom/DeviceOrientationClient.h
Source/WebCore/dom/Range.h
Source/WebCore/dom/ScriptExecutionContext.h
Source/WebCore/dom/StyledElement.h
Source/WebCore/dom/TreeScope.h
Source/WebCore/dom/UIEventWithKeyState.h
Source/WebCore/dom/UserGestureIndicator.h
Source/WebCore/dom/UserTypingGestureIndicator.h
Source/WebCore/dom/ViewportArguments.h
Source/WebCore/editing/SmartReplace.h
Source/WebCore/editing/TextIterator.h
Source/WebCore/editing/VisiblePosition.h
Source/WebCore/editing/VisibleSelection.h
Source/WebCore/editing/VisibleUnits.h
Source/WebCore/editing/cocoa/HTMLConverter.h
Source/WebCore/editing/htmlediting.h
Source/WebCore/editing/mac/TextAlternativeWithRange.h
Source/WebCore/editing/mac/TextUndoInsertionMarkupMac.h
Source/WebCore/editing/markup.h
Source/WebCore/history/HistoryItem.cpp
Source/WebCore/history/PageCache.h
Source/WebCore/html/TimeRanges.h
Source/WebCore/html/parser/HTMLParserIdioms.h
Source/WebCore/inspector/InstrumentingAgents.h
Source/WebCore/loader/FrameLoader.h
Source/WebCore/loader/ResourceBuffer.h
Source/WebCore/loader/ResourceLoadScheduler.h
Source/WebCore/loader/ResourceLoader.h
Source/WebCore/loader/SubframeLoader.h
Source/WebCore/loader/SubresourceLoader.h
Source/WebCore/loader/TextResourceDecoder.h
Source/WebCore/loader/appcache/ApplicationCacheStorage.h
Source/WebCore/loader/cache/MemoryCache.h
Source/WebCore/loader/icon/IconDatabaseBase.h
Source/WebCore/loader/ios/DiskImageCacheIOS.h
Source/WebCore/page/Chrome.h
Source/WebCore/page/SecurityOrigin.h
Source/WebCore/page/SecurityPolicy.h
Source/WebCore/page/Settings.h
Source/WebCore/page/UserContentController.h
Source/WebCore/page/UserContentURLPattern.h
Source/WebCore/page/UserMessageHandlerDescriptor.h
Source/WebCore/page/ViewportConfiguration.h
Source/WebCore/page/VisitedLinkStore.h
Source/WebCore/page/WheelEventDeltaTracker.h
Source/WebCore/page/cocoa/UserAgent.h
Source/WebCore/page/scrolling/ScrollingConstraints.h
Source/WebCore/page/scrolling/ScrollingCoordinator.h
Source/WebCore/page/scrolling/ScrollingStateFixedNode.h
Source/WebCore/page/scrolling/ScrollingStateFrameScrollingNode.h
Source/WebCore/page/scrolling/ScrollingStateNode.h
Source/WebCore/page/scrolling/ScrollingStateOverflowScrollingNode.h
Source/WebCore/page/scrolling/ScrollingStateScrollingNode.h
Source/WebCore/page/scrolling/ScrollingStateStickyNode.h
Source/WebCore/page/scrolling/ScrollingStateTree.h
Source/WebCore/page/scrolling/ScrollingThread.h
Source/WebCore/page/scrolling/ScrollingTree.h
Source/WebCore/page/scrolling/ScrollingTreeOverflowScrollingNode.h
Source/WebCore/page/scrolling/ScrollingTreeScrollingNode.h
Source/WebCore/page/scrolling/ios/ScrollingTreeFrameScrollingNodeIOS.h
Source/WebCore/page/scrolling/mac/ScrollingTreeFixedNode.h
Source/WebCore/page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.h
Source/WebCore/page/scrolling/mac/ScrollingTreeStickyNode.h
Source/WebCore/platform/Cursor.h
Source/WebCore/platform/DragImage.h
Source/WebCore/platform/FileSystem.h
Source/WebCore/platform/Language.h
Source/WebCore/platform/LinkHash.h
Source/WebCore/platform/LocalizedStrings.h
Source/WebCore/platform/Logging.h
Source/WebCore/platform/MemoryPressureHandler.h
Source/WebCore/platform/NotImplemented.h
Source/WebCore/platform/PlatformStrategies.h
Source/WebCore/platform/PublicSuffix.h
Source/WebCore/platform/RuntimeApplicationChecks.h
Source/WebCore/platform/RuntimeApplicationChecksIOS.h
Source/WebCore/platform/SchemeRegistry.h
Source/WebCore/platform/ScrollView.h
Source/WebCore/platform/ScrollableArea.h
Source/WebCore/platform/Scrollbar.h
Source/WebCore/platform/ScrollbarTheme.h
Source/WebCore/platform/SharedBuffer.h
Source/WebCore/platform/ThreadCheck.h
Source/WebCore/platform/ThreadGlobalData.h
Source/WebCore/platform/Timer.h
Source/WebCore/platform/URL.h
Source/WebCore/platform/UUID.h
Source/WebCore/platform/UserActivity.h
Source/WebCore/platform/Widget.h
Source/WebCore/platform/cf/CFURLExtras.h
Source/WebCore/platform/cf/RunLoopObserver.h
Source/WebCore/platform/cocoa/SystemVersion.h
Source/WebCore/platform/graphics/Color.h
Source/WebCore/platform/graphics/FloatRect.h
Source/WebCore/platform/graphics/FontCache.h
Source/WebCore/platform/graphics/GeometryUtilities.h
Source/WebCore/platform/graphics/GraphicsContext.h
Source/WebCore/platform/graphics/IntRect.h
Source/WebCore/platform/graphics/LayoutRect.h
Source/WebCore/platform/graphics/StringTruncator.h
Source/WebCore/platform/graphics/TextRun.h
Source/WebCore/platform/graphics/ca/TileController.h
Source/WebCore/platform/graphics/ca/mac/PlatformCAAnimationMac.h
Source/WebCore/platform/graphics/cg/GraphicsContextCG.h
Source/WebCore/platform/graphics/mac/ColorMac.h
Source/WebCore/platform/graphics/transforms/TransformationMatrix.h
Source/WebCore/platform/ios/FileSystemIOS.h
Source/WebCore/platform/ios/PlatformEventFactoryIOS.h
Source/WebCore/platform/ios/SelectionRect.h
Source/WebCore/platform/ios/SystemMemory.h
Source/WebCore/platform/ios/TileControllerMemoryHandlerIOS.h
Source/WebCore/platform/ios/WebVideoFullscreenInterfaceAVKit.h
Source/WebCore/platform/mac/PlatformEventFactoryMac.h
Source/WebCore/platform/mac/ScrollbarThemeMac.h
Source/WebCore/platform/mac/WebCoreNSURLExtras.h
Source/WebCore/platform/mac/WebNSAttributedStringExtras.h
Source/WebCore/platform/network/BlobRegistry.h
Source/WebCore/platform/network/CookieStorage.h
Source/WebCore/platform/network/DNS.h
Source/WebCore/platform/network/NetworkStateNotifier.h
Source/WebCore/platform/network/PlatformCookieJar.h
Source/WebCore/platform/network/ProxyServer.h
Source/WebCore/platform/network/ResourceErrorBase.h
Source/WebCore/platform/network/ResourceHandle.h
Source/WebCore/platform/network/ResourceHandleClient.h
Source/WebCore/platform/network/ResourceRequestBase.h
Source/WebCore/platform/network/ResourceResponseBase.h
Source/WebCore/platform/network/SynchronousLoaderClient.h
Source/WebCore/platform/network/cf/ResourceError.h
Source/WebCore/platform/network/cf/ResourceRequest.h
Source/WebCore/platform/network/cf/ResourceResponse.h
Source/WebCore/platform/network/ios/QuickLook.h
Source/WebCore/platform/network/mac/AuthenticationMac.h
Source/WebCore/platform/sql/SQLiteDatabase.cpp
Source/WebCore/platform/text/LocaleToScriptMapping.h
Source/WebCore/platform/text/TextBreakIterator.h
Source/WebCore/platform/text/TextEncoding.h
Source/WebCore/platform/text/TextEncodingRegistry.h
Source/WebCore/platform/text/TextStream.h
Source/WebCore/rendering/RenderBlock.h
Source/WebCore/rendering/RenderBox.h
Source/WebCore/rendering/RenderEmbeddedObject.h
Source/WebCore/rendering/RenderLayer.h
Source/WebCore/rendering/RenderLayerBacking.h
Source/WebCore/rendering/RenderLayerCompositor.h
Source/WebCore/rendering/RenderListItem.h
Source/WebCore/rendering/RenderObject.h
Source/WebCore/rendering/RenderText.h
Source/WebCore/rendering/RenderTextControl.h
Source/WebCore/rendering/RenderThemeIOS.h
Source/WebCore/rendering/RenderTreeAsText.h
Source/WebCore/rendering/RenderView.h
Source/WebCore/rendering/RenderWidget.h
Source/WebCore/rendering/ScrollBehavior.cpp
Source/WebCore/rendering/break_lines.cpp
Source/WebCore/rendering/style/RenderStyle.h
Source/WebCore/replay/UserInputBridge.h
Source/WebCore/storage/StorageEventDispatcher.h
Source/WebCore/storage/StorageMap.h
Source/WebCore/storage/StorageStrategy.h
Source/WebCore/storage/StorageTracker.h
Source/WebCore/testing/Internals.h
Source/WebCore/workers/WorkerThread.h

index d323208..4bbf57a 100644 (file)
@@ -1,3 +1,196 @@
+2014-08-21  Alex Christensen  <achristensen@webkit.org>
+
+        More WEBCORE_EXPORT macros!
+        https://bugs.webkit.org/show_bug.cgi?id=136146
+
+        Reviewed by Benjamin Poulain.
+
+        * Modules/geolocation/GeolocationClient.h:
+        * Modules/mediastream/UserMediaClient.h:
+        * Modules/mediastream/UserMediaRequest.h:
+        * Modules/notifications/NotificationClient.h:
+        * Modules/speech/SpeechSynthesis.h:
+        * bindings/generic/RuntimeEnabledFeatures.h:
+        * bindings/js/DOMWrapperWorld.h:
+        * bindings/js/GCController.h:
+        * bindings/js/IDBBindingUtilities.h:
+        * bindings/js/JSDOMBinding.h:
+        * bindings/js/JSNodeCustom.h:
+        * bindings/js/JSNodeListCustom.h:
+        * bindings/js/JSPluginElementFunctions.h:
+        * bindings/js/ScriptController.h:
+        * bindings/js/SerializedScriptValue.h:
+        * crypto/SerializedCryptoKeyWrap.h:
+        * css/LengthFunctions.h:
+        * css/StyleProperties.h:
+        * css/StyleSheetContents.h:
+        * dom/DeviceOrientationClient.h:
+        * dom/Range.h:
+        * dom/ScriptExecutionContext.h:
+        * dom/StyledElement.h:
+        * dom/TreeScope.h:
+        * dom/UIEventWithKeyState.h:
+        * dom/UserGestureIndicator.h:
+        * dom/UserTypingGestureIndicator.h:
+        * dom/ViewportArguments.h:
+        * editing/SmartReplace.h:
+        * editing/TextIterator.h:
+        * editing/VisiblePosition.h:
+        * editing/VisibleSelection.h:
+        * editing/VisibleUnits.h:
+        * editing/cocoa/HTMLConverter.h:
+        * editing/htmlediting.h:
+        * editing/mac/TextAlternativeWithRange.h:
+        * editing/mac/TextUndoInsertionMarkupMac.h:
+        * editing/markup.h:
+        * history/HistoryItem.cpp:
+        * history/PageCache.h:
+        * html/TimeRanges.h:
+        * html/parser/HTMLParserIdioms.h:
+        * inspector/InstrumentingAgents.h:
+        * loader/FrameLoader.h:
+        * loader/ResourceBuffer.h:
+        * loader/ResourceLoadScheduler.h:
+        * loader/ResourceLoader.h:
+        (WebCore::ResourceLoader::originalRequest):
+        * loader/SubframeLoader.h:
+        * loader/SubresourceLoader.h:
+        * loader/TextResourceDecoder.h:
+        * loader/appcache/ApplicationCacheStorage.h:
+        * loader/cache/MemoryCache.h:
+        * loader/icon/IconDatabaseBase.h:
+        * loader/ios/DiskImageCacheIOS.h:
+        * page/Chrome.h:
+        * page/SecurityOrigin.h:
+        * page/SecurityPolicy.h:
+        * page/Settings.h:
+        * page/UserContentController.h:
+        * page/UserContentURLPattern.h:
+        * page/UserMessageHandlerDescriptor.h:
+        * page/ViewportConfiguration.h:
+        * page/VisitedLinkStore.h:
+        * page/WheelEventDeltaTracker.h:
+        * page/cocoa/UserAgent.h:
+        * page/scrolling/ScrollingConstraints.h:
+        * page/scrolling/ScrollingCoordinator.h:
+        * page/scrolling/ScrollingStateFixedNode.h:
+        * page/scrolling/ScrollingStateFrameScrollingNode.h:
+        * page/scrolling/ScrollingStateNode.h:
+        * page/scrolling/ScrollingStateOverflowScrollingNode.h:
+        * page/scrolling/ScrollingStateScrollingNode.h:
+        * page/scrolling/ScrollingStateStickyNode.h:
+        * page/scrolling/ScrollingStateTree.h:
+        * page/scrolling/ScrollingThread.h:
+        * page/scrolling/ScrollingTree.h:
+        * page/scrolling/ScrollingTreeOverflowScrollingNode.h:
+        * page/scrolling/ScrollingTreeScrollingNode.h:
+        * page/scrolling/ios/ScrollingTreeFrameScrollingNodeIOS.h:
+        * page/scrolling/mac/ScrollingTreeFixedNode.h:
+        * page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.h:
+        * page/scrolling/mac/ScrollingTreeStickyNode.h:
+        * platform/Cursor.h:
+        * platform/DragImage.h:
+        * platform/FileSystem.h:
+        * platform/Language.h:
+        * platform/LinkHash.h:
+        * platform/LocalizedStrings.h:
+        * platform/Logging.h:
+        * platform/MemoryPressureHandler.h:
+        * platform/NotImplemented.h:
+        * platform/PlatformStrategies.h:
+        * platform/PublicSuffix.h:
+        * platform/RuntimeApplicationChecks.h:
+        * platform/RuntimeApplicationChecksIOS.h:
+        * platform/SchemeRegistry.h:
+        * platform/ScrollView.h:
+        * platform/ScrollableArea.h:
+        * platform/Scrollbar.h:
+        * platform/ScrollbarTheme.h:
+        * platform/SharedBuffer.h:
+        * platform/ThreadCheck.h:
+        * platform/ThreadGlobalData.h:
+        * platform/Timer.h:
+        * platform/URL.h:
+        * platform/UUID.h:
+        * platform/UserActivity.h:
+        * platform/Widget.h:
+        * platform/cf/CFURLExtras.h:
+        * platform/cf/RunLoopObserver.h:
+        * platform/cocoa/SystemVersion.h:
+        * platform/graphics/Color.h:
+        * platform/graphics/FloatRect.h:
+        * platform/graphics/FontCache.h:
+        * platform/graphics/GeometryUtilities.h:
+        * platform/graphics/GraphicsContext.h:
+        * platform/graphics/IntRect.h:
+        * platform/graphics/LayoutRect.h:
+        * platform/graphics/StringTruncator.h:
+        * platform/graphics/TextRun.h:
+        * platform/graphics/ca/TileController.h:
+        * platform/graphics/ca/mac/PlatformCAAnimationMac.h:
+        * platform/graphics/cg/GraphicsContextCG.h:
+        * platform/graphics/mac/ColorMac.h:
+        * platform/graphics/transforms/TransformationMatrix.h:
+        * platform/ios/FileSystemIOS.h:
+        * platform/ios/PlatformEventFactoryIOS.h:
+        * platform/ios/SelectionRect.h:
+        * platform/ios/SystemMemory.h:
+        * platform/ios/TileControllerMemoryHandlerIOS.h:
+        * platform/ios/WebVideoFullscreenInterfaceAVKit.h:
+        * platform/mac/PlatformEventFactoryMac.h:
+        * platform/mac/ScrollbarThemeMac.h:
+        * platform/mac/WebCoreNSURLExtras.h:
+        * platform/mac/WebNSAttributedStringExtras.h:
+        * platform/network/BlobRegistry.h:
+        * platform/network/CookieStorage.h:
+        * platform/network/DNS.h:
+        * platform/network/NetworkStateNotifier.h:
+        * platform/network/PlatformCookieJar.h:
+        * platform/network/ProxyServer.h:
+        * platform/network/ResourceErrorBase.h:
+        * platform/network/ResourceHandle.h:
+        * platform/network/ResourceHandleClient.h:
+        * platform/network/ResourceRequestBase.h:
+        * platform/network/ResourceResponseBase.h:
+        * platform/network/SynchronousLoaderClient.h:
+        * platform/network/cf/ResourceError.h:
+        * platform/network/cf/ResourceRequest.h:
+        * platform/network/cf/ResourceResponse.h:
+        * platform/network/ios/QuickLook.h:
+        * platform/network/mac/AuthenticationMac.h:
+        * platform/sql/SQLiteDatabase.cpp:
+        * platform/text/LocaleToScriptMapping.h:
+        * platform/text/TextBreakIterator.h:
+        * platform/text/TextEncoding.h:
+        (WebCore::TextEncoding::decode):
+        * platform/text/TextEncodingRegistry.h:
+        * platform/text/TextStream.h:
+        * rendering/RenderBlock.h:
+        * rendering/RenderBox.h:
+        * rendering/RenderEmbeddedObject.h:
+        * rendering/RenderLayer.h:
+        * rendering/RenderLayerBacking.h:
+        * rendering/RenderLayerCompositor.h:
+        * rendering/RenderListItem.h:
+        * rendering/RenderObject.h:
+        * rendering/RenderText.h:
+        * rendering/RenderTextControl.h:
+        * rendering/RenderThemeIOS.h:
+        * rendering/RenderTreeAsText.h:
+        * rendering/RenderView.h:
+        * rendering/RenderWidget.h:
+        * rendering/ScrollBehavior.cpp:
+        * rendering/break_lines.cpp:
+        * rendering/style/RenderStyle.h:
+        * replay/UserInputBridge.h:
+        * storage/StorageEventDispatcher.h:
+        * storage/StorageMap.h:
+        * storage/StorageStrategy.h:
+        * storage/StorageTracker.h:
+        * testing/Internals.h:
+        * workers/WorkerThread.h:
+        Added more WEBCORE_EXPORT macros where needed.
+
 2014-08-21  Tim Horton  <timothy_horton@apple.com>
 
         Revert r172831, it broke the Windows build.
index d893871..af6cbe6 100644 (file)
@@ -54,7 +54,7 @@ protected:
     virtual ~GeolocationClient() { }
 };
 
-void provideGeolocationTo(Page*, GeolocationClient*);
+WEBCORE_EXPORT void provideGeolocationTo(Page*, GeolocationClient*);
 
 } // namespace WebCore
 
index b847c78..c8995b9 100644 (file)
@@ -51,7 +51,7 @@ protected:
     virtual ~UserMediaClient() { }
 };
 
-void provideUserMediaTo(Page*, UserMediaClient*);
+WEBCORE_EXPORT void provideUserMediaTo(Page*, UserMediaClient*);
 
 } // namespace WebCore
 
index 6ad20fe..c80a6ba 100644 (file)
@@ -60,11 +60,11 @@ public:
     static PassRefPtr<UserMediaRequest> create(ScriptExecutionContext*, UserMediaController*, const Dictionary& options, PassRefPtr<NavigatorUserMediaSuccessCallback>, PassRefPtr<NavigatorUserMediaErrorCallback>, ExceptionCode&);
     ~UserMediaRequest();
 
-    SecurityOrigin* securityOrigin() const;
+    WEBCORE_EXPORT SecurityOrigin* securityOrigin() const;
 
     void start();
-    void userMediaAccessGranted();
-    void userMediaAccessDenied();
+    WEBCORE_EXPORT void userMediaAccessGranted();
+    WEBCORE_EXPORT void userMediaAccessDenied();
 
 private:
     UserMediaRequest(ScriptExecutionContext*, UserMediaController*, PassRefPtr<MediaConstraints> audioConstraints, PassRefPtr<MediaConstraints> videoConstraints, PassRefPtr<NavigatorUserMediaSuccessCallback>, PassRefPtr<NavigatorUserMediaErrorCallback>);
index 22815bf..b0fe647 100644 (file)
@@ -91,7 +91,7 @@ protected:
     virtual ~NotificationClient() { }
 };
 
-void provideNotification(Page*, NotificationClient*);
+WEBCORE_EXPORT void provideNotification(Page*, NotificationClient*);
 
 } // namespace WebCore
 
index b399c7c..da61f90 100644 (file)
@@ -58,7 +58,7 @@ public:
     const Vector<RefPtr<SpeechSynthesisVoice>>& getVoices();
     
     // Used in testing to use a mock platform synthesizer
-    void setPlatformSynthesizer(std::unique_ptr<PlatformSpeechSynthesizer>);
+    WEBCORE_EXPORT void setPlatformSynthesizer(std::unique_ptr<PlatformSpeechSynthesizer>);
     
 private:
     SpeechSynthesis();
index 822eca2..e97e116 100644 (file)
@@ -200,7 +200,7 @@ public:
     bool gamepadsEnabled() const { return m_areGamepadsEnabled; }
 #endif
 
-    static RuntimeEnabledFeatures& sharedFeatures();
+    WEBCORE_EXPORT static RuntimeEnabledFeatures& sharedFeatures();
 
 private:
     // Never instantiate.
index 5bf55ae..b3f369a 100644 (file)
@@ -65,7 +65,7 @@ private:
 };
 
 DOMWrapperWorld& normalWorld(JSC::VM&);
-DOMWrapperWorld& mainThreadNormalWorld();
+WEBCORE_EXPORT DOMWrapperWorld& mainThreadNormalWorld();
 inline DOMWrapperWorld& debuggerWorld() { return mainThreadNormalWorld(); }
 inline DOMWrapperWorld& pluginWorld() { return mainThreadNormalWorld(); }
 
index 39381df..f02a632 100644 (file)
@@ -58,7 +58,7 @@ namespace WebCore {
     };
 
     // Function to obtain the global GC controller.
-    GCController& gcController() PURE_FUNCTION;
+    WEBCORE_EXPORT GCController& gcController() PURE_FUNCTION;
 
 } // namespace WebCore
 
index b270c56..d008321 100644 (file)
@@ -49,10 +49,10 @@ PassRefPtr<IDBKey> createIDBKeyFromScriptValueAndKeyPath(JSC::ExecState*, const
 bool canInjectIDBKeyIntoScriptValue(DOMRequestState*, const Deprecated::ScriptValue&, const IDBKeyPath&);
 Deprecated::ScriptValue deserializeIDBValue(DOMRequestState*, PassRefPtr<SerializedScriptValue>);
 Deprecated::ScriptValue deserializeIDBValueBuffer(DOMRequestState*, PassRefPtr<SharedBuffer>, bool keyIsDefined);
-Deprecated::ScriptValue deserializeIDBValueBuffer(JSC::ExecState*, const Vector<uint8_t>&, bool keyIsDefined);
+WEBCORE_EXPORT Deprecated::ScriptValue deserializeIDBValueBuffer(JSC::ExecState*, const Vector<uint8_t>&, bool keyIsDefined);
 Deprecated::ScriptValue idbKeyToScriptValue(DOMRequestState*, PassRefPtr<IDBKey>);
 PassRefPtr<IDBKey> scriptValueToIDBKey(DOMRequestState*, const Deprecated::ScriptValue&);
-void generateIndexKeysForValue(JSC::ExecState*, const IDBIndexMetadata&, const Deprecated::ScriptValue& objectValue, Vector<IDBKeyData>& indexKeys);
+WEBCORE_EXPORT void generateIndexKeysForValue(JSC::ExecState*, const IDBIndexMetadata&, const Deprecated::ScriptValue& objectValue, Vector<IDBKeyData>& indexKeys);
 
 }
 
index 04d953b..e77ab1d 100644 (file)
@@ -77,20 +77,20 @@ typedef int ExceptionCode;
 DOMWindow& activeDOMWindow(JSC::ExecState*);
 DOMWindow& firstDOMWindow(JSC::ExecState*);
 
-JSC::EncodedJSValue reportDeprecatedGetterError(JSC::ExecState&, const char* interfaceName, const char* attributeName);
-void reportDeprecatedSetterError(JSC::ExecState&, const char* interfaceName, const char* attributeName);
+WEBCORE_EXPORT JSC::EncodedJSValue reportDeprecatedGetterError(JSC::ExecState&, const char* interfaceName, const char* attributeName);
+WEBCORE_EXPORT void reportDeprecatedSetterError(JSC::ExecState&, const char* interfaceName, const char* attributeName);
 
 void throwArrayElementTypeError(JSC::ExecState&);
 void throwAttributeTypeError(JSC::ExecState&, const char* interfaceName, const char* attributeName, const char* expectedType);
-void throwSequenceTypeError(JSC::ExecState&);
-void throwSetterTypeError(JSC::ExecState&, const char* interfaceName, const char* attributeName);
+WEBCORE_EXPORT void throwSequenceTypeError(JSC::ExecState&);
+WEBCORE_EXPORT void throwSetterTypeError(JSC::ExecState&, const char* interfaceName, const char* attributeName);
 
 JSC::EncodedJSValue throwArgumentMustBeEnumError(JSC::ExecState&, unsigned argumentIndex, const char* argumentName, const char* functionInterfaceName, const char* functionName, const char* expectedValues);
 JSC::EncodedJSValue throwArgumentMustBeFunctionError(JSC::ExecState&, unsigned argumentIndex, const char* argumentName, const char* functionInterfaceName, const char* functionName);
 JSC::EncodedJSValue throwArgumentTypeError(JSC::ExecState&, unsigned argumentIndex, const char* argumentName, const char* functionInterfaceName, const char* functionName, const char* expectedType);
 JSC::EncodedJSValue throwConstructorDocumentUnavailableError(JSC::ExecState&, const char* interfaceName);
-JSC::EncodedJSValue throwGetterTypeError(JSC::ExecState&, const char* interfaceName, const char* attributeName);
-JSC::EncodedJSValue throwThisTypeError(JSC::ExecState&, const char* interfaceName, const char* functionName);
+WEBCORE_EXPORT JSC::EncodedJSValue throwGetterTypeError(JSC::ExecState&, const char* interfaceName, const char* attributeName);
+WEBCORE_EXPORT JSC::EncodedJSValue throwThisTypeError(JSC::ExecState&, const char* interfaceName, const char* functionName);
 
 // Base class for all constructor objects in the JSC bindings.
 class DOMConstructorObject : public JSDOMWrapper {
@@ -109,8 +109,8 @@ protected:
     }
 };
 
-JSC::Structure* getCachedDOMStructure(JSDOMGlobalObject*, const JSC::ClassInfo*);
-JSC::Structure* cacheDOMStructure(JSDOMGlobalObject*, JSC::Structure*, const JSC::ClassInfo*);
+WEBCORE_EXPORT JSC::Structure* getCachedDOMStructure(JSDOMGlobalObject*, const JSC::ClassInfo*);
+WEBCORE_EXPORT JSC::Structure* cacheDOMStructure(JSDOMGlobalObject*, JSC::Structure*, const JSC::ClassInfo*);
 
 inline JSDOMGlobalObject* deprecatedGlobalObjectForPrototype(JSC::ExecState* exec)
 {
@@ -262,11 +262,11 @@ void addImpureProperty(const AtomicString&);
 
 const JSC::HashTable& getHashTableForGlobalData(JSC::VM&, const JSC::HashTable& staticTable);
 
-void reportException(JSC::ExecState*, JSC::JSValue exception, CachedScript* = nullptr);
+WEBCORE_EXPORT void reportException(JSC::ExecState*, JSC::JSValue exception, CachedScript* = nullptr);
 void reportCurrentException(JSC::ExecState*);
 
 // Convert a DOM implementation exception code into a JavaScript exception in the execution state.
-void setDOMException(JSC::ExecState*, ExceptionCode);
+WEBCORE_EXPORT void setDOMException(JSC::ExecState*, ExceptionCode);
 
 JSC::JSValue jsString(JSC::ExecState*, const URL&); // empty if the URL is null
 
@@ -450,7 +450,7 @@ template<typename T, size_t inlineCapacity> JSC::JSValue jsArray(JSC::ExecState*
     return JSC::constructArray(exec, nullptr, globalObject, list);
 }
 
-JSC::JSValue jsArray(JSC::ExecState*, JSDOMGlobalObject*, PassRefPtr<DOMStringList>);
+WEBCORE_EXPORT JSC::JSValue jsArray(JSC::ExecState*, JSDOMGlobalObject*, PassRefPtr<DOMStringList>);
 
 inline PassRefPtr<JSC::ArrayBufferView> toArrayBufferView(JSC::JSValue value)
 {
index d66334e..78d2d6e 100644 (file)
@@ -33,8 +33,8 @@
 
 namespace WebCore {
 
-JSC::JSValue createWrapper(JSC::ExecState*, JSDOMGlobalObject*, Node*);
-JSC::JSObject* getOutOfLineCachedWrapper(JSDOMGlobalObject*, Node*);
+WEBCORE_EXPORT JSC::JSValue createWrapper(JSC::ExecState*, JSDOMGlobalObject*, Node*);
+WEBCORE_EXPORT JSC::JSObject* getOutOfLineCachedWrapper(JSDOMGlobalObject*, Node*);
 
 inline JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, Node* node)
 {
index 8a00261..df4b2b9 100644 (file)
@@ -31,7 +31,7 @@
 
 namespace WebCore {
 
-JSC::JSValue createWrapper(JSDOMGlobalObject&, NodeList&);
+WEBCORE_EXPORT JSC::JSValue createWrapper(JSDOMGlobalObject&, NodeList&);
 
 ALWAYS_INLINE JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject* globalObject, NodeList* nodeList)
 {
index 52b1883..776cf17 100644 (file)
@@ -36,7 +36,7 @@ namespace WebCore {
     // JavaScript access to plug-in-exported properties for JSHTMLAppletElement, JSHTMLEmbedElement and JSHTMLObjectElement.
 
     JSC::Bindings::Instance* pluginInstance(HTMLElement&);
-    JSC::JSObject* pluginScriptObject(JSC::ExecState*, JSHTMLElement*);
+    WEBCORE_EXPORT JSC::JSObject* pluginScriptObject(JSC::ExecState*, JSHTMLElement*);
 
     JSC::EncodedJSValue pluginElementPropertyGetter(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::PropertyName);
     bool pluginElementCustomGetOwnPropertySlot(JSC::ExecState*, JSC::PropertyName, JSC::PropertySlot&, JSHTMLElement*);
index 69bf177..646e5ca 100644 (file)
@@ -77,7 +77,7 @@ public:
     explicit ScriptController(Frame&);
     ~ScriptController();
 
-    static PassRefPtr<DOMWrapperWorld> createWorld();
+    WEBCORE_EXPORT static PassRefPtr<DOMWrapperWorld> createWorld();
 
     JSDOMWindowShell* createWindowShell(DOMWrapperWorld&);
     void destroyWindowShell(DOMWrapperWorld&);
@@ -102,8 +102,8 @@ public:
     static void getAllWorlds(Vector<Ref<DOMWrapperWorld>>&);
 
     Deprecated::ScriptValue executeScript(const ScriptSourceCode&);
-    Deprecated::ScriptValue executeScript(const String& script, bool forceUserGesture = false);
-    Deprecated::ScriptValue executeScriptInWorld(DOMWrapperWorld&, const String& script, bool forceUserGesture = false);
+    WEBCORE_EXPORT Deprecated::ScriptValue executeScript(const String& script, bool forceUserGesture = false);
+    WEBCORE_EXPORT Deprecated::ScriptValue executeScriptInWorld(DOMWrapperWorld&, const String& script, bool forceUserGesture = false);
 
     // Returns true if argument is a JavaScript URL.
     bool executeIfJavaScriptURL(const URL&, ShouldReplaceDocumentIfJavaScriptURL shouldReplaceDocumentIfJavaScriptURL = ReplaceDocumentIfJavaScriptURL);
@@ -120,10 +120,10 @@ public:
     void enableEval();
     void disableEval(const String& errorMessage);
 
-    static bool processingUserGesture();
+    WEBCORE_EXPORT static bool processingUserGesture();
 
     static bool canAccessFromCurrentOrigin(Frame*);
-    bool canExecuteScripts(ReasonForCallingCanExecuteScripts);
+    WEBCORE_EXPORT bool canExecuteScripts(ReasonForCallingCanExecuteScripts);
 
     // Debugger can be 0 to detach any existing Debugger.
     void attachDebugger(JSC::Debugger*); // Attaches/detaches in all worlds/window shells.
@@ -141,7 +141,7 @@ public:
     void namedItemRemoved(HTMLDocument*, const AtomicString&) { }
 
     void clearScriptObjects();
-    void cleanupScriptObjectsForPlugin(void*);
+    WEBCORE_EXPORT void cleanupScriptObjectsForPlugin(void*);
 
     void updatePlatformScriptObjects();
 
@@ -149,28 +149,28 @@ public:
     JSC::Bindings::RootObject* bindingRootObject();
     JSC::Bindings::RootObject* cacheableBindingRootObject();
 
-    PassRefPtr<JSC::Bindings::RootObject> createRootObject(void* nativeHandle);
+    WEBCORE_EXPORT PassRefPtr<JSC::Bindings::RootObject> createRootObject(void* nativeHandle);
 
 #if ENABLE(INSPECTOR)
     void collectIsolatedContexts(Vector<std::pair<JSC::ExecState*, SecurityOrigin*>>&);
 #endif
 
 #if PLATFORM(COCOA)
-    WebScriptObject* windowScriptObject();
-    JSContext *javaScriptContext();
+    WEBCORE_EXPORT WebScriptObject* windowScriptObject();
+    WEBCORE_EXPORT JSContext *javaScriptContext();
 #endif
 
-    JSC::JSObject* jsObjectForPluginElement(HTMLPlugInElement*);
+    WEBCORE_EXPORT JSC::JSObject* jsObjectForPluginElement(HTMLPlugInElement*);
     
 #if ENABLE(NETSCAPE_PLUGIN_API)
     NPObject* createScriptObjectForPluginElement(HTMLPlugInElement*);
-    NPObject* windowScriptNPObject();
+    WEBCORE_EXPORT NPObject* windowScriptNPObject();
 #endif
 
     bool shouldBypassMainWorldContentSecurityPolicy();
 
 private:
-    JSDOMWindowShell* initScript(DOMWrapperWorld&);
+    WEBCORE_EXPORT JSDOMWindowShell* initScript(DOMWrapperWorld&);
 
     void disconnectPlatformScriptObjects();
 
index 7bac1a7..4e4aae7 100644 (file)
@@ -67,9 +67,9 @@ class SerializedScriptValue :
     public RefCounted<SerializedScriptValue> {
 #endif
 public:
-    static PassRefPtr<SerializedScriptValue> create(JSC::ExecState*, JSC::JSValue, MessagePortArray*, ArrayBufferArray*, SerializationErrorMode = Throwing);
+    WEBCORE_EXPORT static PassRefPtr<SerializedScriptValue> create(JSC::ExecState*, JSC::JSValue, MessagePortArray*, ArrayBufferArray*, SerializationErrorMode = Throwing);
 
-    static PassRefPtr<SerializedScriptValue> create(const String&);
+    WEBCORE_EXPORT static PassRefPtr<SerializedScriptValue> create(const String&);
     static PassRefPtr<SerializedScriptValue> adopt(Vector<uint8_t>& buffer)
     {
         return adoptRef(new SerializedScriptValue(buffer));
@@ -77,15 +77,15 @@ public:
 
     static PassRefPtr<SerializedScriptValue> nullValue();
 
-    JSC::JSValue deserialize(JSC::ExecState*, JSC::JSGlobalObject*, MessagePortArray*, SerializationErrorMode = Throwing);
+    WEBCORE_EXPORT JSC::JSValue deserialize(JSC::ExecState*, JSC::JSGlobalObject*, MessagePortArray*, SerializationErrorMode = Throwing);
 
     static uint32_t wireFormatVersion();
 
     String toString();
 
     // API implementation helpers. These don't expose special behavior for ArrayBuffers or MessagePorts.
-    static PassRefPtr<SerializedScriptValue> create(JSContextRef, JSValueRef, JSValueRef* exception);
-    JSValueRef deserialize(JSContextRef, JSValueRef* exception);
+    WEBCORE_EXPORT static PassRefPtr<SerializedScriptValue> create(JSContextRef, JSValueRef, JSValueRef* exception);
+    WEBCORE_EXPORT JSValueRef deserialize(JSContextRef, JSValueRef* exception);
 
     const Vector<uint8_t>& data() const { return m_data; }
     bool hasBlobURLs() const { return !m_blobURLs.isEmpty(); }
@@ -103,7 +103,7 @@ public:
     }
     const Vector<uint8_t>& toWireBytes() const { return m_data; }
 
-    ~SerializedScriptValue();
+    WEBCORE_EXPORT ~SerializedScriptValue();
 
 private:
     typedef Vector<JSC::ArrayBufferContents> ArrayBufferContentsArray;
@@ -113,7 +113,7 @@ private:
     void addBlobURL(const String&);
 
     SerializedScriptValue(const Vector<unsigned char>&);
-    SerializedScriptValue(Vector<unsigned char>&);
+    WEBCORE_EXPORT SerializedScriptValue(Vector<unsigned char>&);
     SerializedScriptValue(Vector<unsigned char>&, Vector<String>& blobURLs);
     SerializedScriptValue(Vector<unsigned char>&, Vector<String>& blobURLs, PassOwnPtr<ArrayBufferContentsArray>);
 
index 3a6bcc7..8607043 100644 (file)
 
 namespace WebCore {
 
-bool getDefaultWebCryptoMasterKey(Vector<uint8_t>&);
+WEBCORE_EXPORT bool getDefaultWebCryptoMasterKey(Vector<uint8_t>&);
 
-bool wrapSerializedCryptoKey(const Vector<uint8_t>& masterKey, const Vector<uint8_t>& key, Vector<uint8_t>& result);
-bool unwrapSerializedCryptoKey(const Vector<uint8_t>& masterKey, const Vector<uint8_t>& wrappedKey, Vector<uint8_t>& key);
+WEBCORE_EXPORT bool wrapSerializedCryptoKey(const Vector<uint8_t>& masterKey, const Vector<uint8_t>& key, Vector<uint8_t>& result);
+WEBCORE_EXPORT bool unwrapSerializedCryptoKey(const Vector<uint8_t>& masterKey, const Vector<uint8_t>& wrappedKey, Vector<uint8_t>& key);
 
 }
 
index 13428d7..20a4fc5 100644 (file)
@@ -37,7 +37,7 @@ int intValueForLength(const Length&, LayoutUnit maximumValue);
 LayoutUnit minimumValueForLength(const Length&, LayoutUnit maximumValue, bool roundPercentages = false);
 LayoutUnit valueForLength(const Length&, LayoutUnit maximumValue);
 float floatValueForLength(const Length&, LayoutUnit maximumValue);
-float floatValueForLength(const Length&, float maximumValue);
+WEBCORE_EXPORT float floatValueForLength(const Length&, float maximumValue);
 FloatSize floatSizeForLengthSize(const LengthSize&, const FloatSize&);
 
 } // namespace WebCore
index e1b42c4..a9c2fa6 100644 (file)
@@ -101,7 +101,7 @@ public:
 
     void addSubresourceStyleURLs(ListHashSet<URL>&, StyleSheetContents* contextStyleSheet) const;
 
-    PassRef<MutableStyleProperties> mutableCopy() const;
+    WEBCORE_EXPORT PassRef<MutableStyleProperties> mutableCopy() const;
     PassRef<ImmutableStyleProperties> immutableCopyIfNeeded() const;
 
     PassRef<MutableStyleProperties> copyPropertiesInSet(const CSSPropertyID* set, unsigned length) const;
index 9500007..7698a03 100644 (file)
@@ -54,14 +54,14 @@ public:
         return adoptRef(*new StyleSheetContents(ownerRule, originalURL, context));
     }
 
-    ~StyleSheetContents();
+    WEBCORE_EXPORT ~StyleSheetContents();
     
     const CSSParserContext& parserContext() const { return m_parserContext; }
 
     const AtomicString& determineNamespace(const AtomicString& prefix);
 
     void parseAuthorStyleSheet(const CachedCSSStyleSheet*, const SecurityOrigin*);
-    bool parseString(const String&);
+    WEBCORE_EXPORT bool parseString(const String&);
     bool parseStringAtLine(const String&, int startLineNumber, bool);
 
     bool isCacheable() const;
index 5b5d176..d6fbf7e 100644 (file)
@@ -46,7 +46,7 @@ public:
     virtual void deviceOrientationControllerDestroyed() = 0;
 };
 
-void provideDeviceOrientationTo(Page*, DeviceOrientationClient*);
+WEBCORE_EXPORT void provideDeviceOrientationTo(Page*, DeviceOrientationClient*);
 
 } // namespace WebCore
 
index 2f4a4ac..c4b31af 100644 (file)
@@ -188,7 +188,7 @@ private:
 
 PassRefPtr<Range> rangeOfContents(Node&);
 
-bool areRangesEqual(const Range*, const Range*);
+WEBCORE_EXPORT bool areRangesEqual(const Range*, const Range*);
 bool rangesOverlap(const Range*, const Range*);
 
 } // namespace
index 269c3a5..002c961 100644 (file)
@@ -83,7 +83,7 @@ public:
     PublicURLManager& publicURLManager();
 
     // Active objects are not garbage collected even if inaccessible, e.g. because their activity may result in callbacks being invoked.
-    bool canSuspendActiveDOMObjects();
+    WEBCORE_EXPORT bool canSuspendActiveDOMObjects();
     // Active objects can be asked to suspend even if canSuspendActiveDOMObjects() returns 'false' -
     // step-by-step JS debugging is one example.
     virtual void suspendActiveDOMObjects(ActiveDOMObject::ReasonForSuspension);
@@ -154,7 +154,7 @@ public:
     void removeTimeout(int timeoutId) { m_timeouts.remove(timeoutId); }
     DOMTimer* findTimeout(int timeoutId) { return m_timeouts.get(timeoutId); }
 
-    JSC::VM& vm();
+    WEBCORE_EXPORT JSC::VM& vm();
 
     // Interval is in seconds.
     void adjustMinimumTimerInterval(double oldMinimumTimerInterval);
index 565501b..afcebf9 100644 (file)
@@ -50,8 +50,8 @@ public:
     
     bool setInlineStyleProperty(CSSPropertyID, CSSValueID identifier, bool important = false);
     bool setInlineStyleProperty(CSSPropertyID, CSSPropertyID identifier, bool important = false);
-    bool setInlineStyleProperty(CSSPropertyID, double value, CSSPrimitiveValue::UnitTypes, bool important = false);
-    bool setInlineStyleProperty(CSSPropertyID, const String& value, bool important = false);
+    WEBCORE_EXPORT bool setInlineStyleProperty(CSSPropertyID, double value, CSSPrimitiveValue::UnitTypes, bool important = false);
+    WEBCORE_EXPORT bool setInlineStyleProperty(CSSPropertyID, const String& value, bool important = false);
     bool removeInlineStyleProperty(CSSPropertyID);
     void removeAllInlineStyleProperties();
 
index 3c79c0e..f1af3bf 100644 (file)
@@ -55,7 +55,7 @@ public:
 
     Element* focusedElement();
     Element* getElementById(const AtomicString&) const;
-    Element* getElementById(const String&) const;
+    WEBCORE_EXPORT Element* getElementById(const String&) const;
     const Vector<Element*>* getAllElementsById(const AtomicString&) const;
     bool hasElementWithId(const AtomicStringImpl&) const;
     bool containsMultipleElementsWithId(const AtomicString& id) const;
index 5b9ce11..e6adc6b 100644 (file)
@@ -71,7 +71,7 @@ namespace WebCore {
         bool m_metaKey : 1;
     };
 
-    UIEventWithKeyState* findEventWithKeyState(Event*);
+    WEBCORE_EXPORT UIEventWithKeyState* findEventWithKeyState(Event*);
 
 } // namespace WebCore
 
index d137c00..355ca69 100644 (file)
@@ -41,12 +41,12 @@ class UserGestureIndicator {
 public:
     static bool processingUserGesture();
 
-    explicit UserGestureIndicator(ProcessingUserGestureState);
-    ~UserGestureIndicator();
+    WEBCORE_EXPORT explicit UserGestureIndicator(ProcessingUserGestureState);
+    WEBCORE_EXPORT ~UserGestureIndicator();
 
 
 private:
-    static ProcessingUserGestureState s_state;
+    WEBCORE_EXPORT static ProcessingUserGestureState s_state;
     ProcessingUserGestureState m_previousState;
 };
 
index d92e95a..0ee18b1 100644 (file)
@@ -37,8 +37,8 @@ class Node;
 class UserTypingGestureIndicator {
     WTF_MAKE_NONCOPYABLE(UserTypingGestureIndicator);
 public:
-    static bool processingUserTypingGesture();
-    static Node* focusedElementAtGestureStart();
+    WEBCORE_EXPORT static bool processingUserTypingGesture();
+    WEBCORE_EXPORT static Node* focusedElementAtGestureStart();
 
     explicit UserTypingGestureIndicator(Frame&);
     ~UserTypingGestureIndicator();
index a018152..9a6137d 100644 (file)
@@ -143,10 +143,10 @@ struct ViewportArguments {
 #endif
 };
 
-ViewportAttributes computeViewportAttributes(ViewportArguments args, int desktopWidth, int deviceWidth, int deviceHeight, float devicePixelRatio, IntSize visibleViewport);
+WEBCORE_EXPORT ViewportAttributes computeViewportAttributes(ViewportArguments args, int desktopWidth, int deviceWidth, int deviceHeight, float devicePixelRatio, IntSize visibleViewport);
 
-void restrictMinimumScaleFactorToViewportSize(ViewportAttributes& result, IntSize visibleViewport, float devicePixelRatio);
-void restrictScaleFactorToInitialScaleIfNotUserScalable(ViewportAttributes& result);
+WEBCORE_EXPORT void restrictMinimumScaleFactorToViewportSize(ViewportAttributes& result, IntSize visibleViewport, float devicePixelRatio);
+WEBCORE_EXPORT void restrictScaleFactorToInitialScaleIfNotUserScalable(ViewportAttributes& result);
 float computeMinimumScaleFactorForContentContained(const ViewportAttributes& result, const IntSize& viewportSize, const IntSize& contentSize);
 
 void setViewportFeature(const String& keyString, const String& valueString, Document*, void* data);
index e665513..9e9eb5d 100644 (file)
@@ -33,7 +33,7 @@
 
 namespace WebCore {
 
-bool isCharacterSmartReplaceExempt(UChar32 c, bool isPreviousCharacter);
+WEBCORE_EXPORT bool isCharacterSmartReplaceExempt(UChar32 c, bool isPreviousCharacter);
 
 } // namespace WebCore
 
index 4017970..c7f0c3a 100644 (file)
@@ -40,8 +40,8 @@ class InlineTextBox;
 class RenderText;
 class RenderTextFragment;
 
-String plainText(const Range*, TextIteratorBehavior = TextIteratorDefaultBehavior, bool isDisplayString = false);
-String plainTextReplacingNoBreakSpace(const Range*, TextIteratorBehavior = TextIteratorDefaultBehavior, bool isDisplayString = false);
+WEBCORE_EXPORT String plainText(const Range*, TextIteratorBehavior = TextIteratorDefaultBehavior, bool isDisplayString = false);
+WEBCORE_EXPORT String plainTextReplacingNoBreakSpace(const Range*, TextIteratorBehavior = TextIteratorDefaultBehavior, bool isDisplayString = false);
 PassRefPtr<Range> findPlainText(const Range&, const String&, FindOptions);
 
 // FIXME: Move this somewhere else in the editing directory. It doesn't belong here.
@@ -93,23 +93,23 @@ private:
 
 class TextIterator {
 public:
-    explicit TextIterator(const Range*, TextIteratorBehavior = TextIteratorDefaultBehavior);
-    ~TextIterator();
+    WEBCORE_EXPORT explicit TextIterator(const Range*, TextIteratorBehavior = TextIteratorDefaultBehavior);
+    WEBCORE_EXPORT ~TextIterator();
 
     bool atEnd() const { return !m_positionNode; }
-    void advance();
+    WEBCORE_EXPORT void advance();
 
     StringView text() const { ASSERT(!atEnd()); return m_text; }
     PassRefPtr<Range> range() const;
-    Node* node() const;
+    WEBCORE_EXPORT Node* node() const;
 
     const TextIteratorCopyableText& copyableText() const { ASSERT(!atEnd()); return m_copyableText; }
     void appendTextToStringBuilder(StringBuilder& builder) const { copyableText().appendToStringBuilder(builder); }
 
-    static int rangeLength(const Range*, bool spacesForReplacedElements = false);
-    static PassRefPtr<Range> rangeFromLocationAndLength(ContainerNode* scope, int rangeLocation, int rangeLength, bool spacesForReplacedElements = false);
-    static bool getLocationAndLengthFromRange(Node* scope, const Range*, size_t& location, size_t& length);
-    static PassRefPtr<Range> subrange(Range* entireRange, int characterOffset, int characterCount);
+    WEBCORE_EXPORT static int rangeLength(const Range*, bool spacesForReplacedElements = false);
+    WEBCORE_EXPORT static PassRefPtr<Range> rangeFromLocationAndLength(ContainerNode* scope, int rangeLocation, int rangeLength, bool spacesForReplacedElements = false);
+    WEBCORE_EXPORT static bool getLocationAndLengthFromRange(Node* scope, const Range*, size_t& location, size_t& length);
+    WEBCORE_EXPORT static PassRefPtr<Range> subrange(Range* entireRange, int characterOffset, int characterCount);
 
 private:
     void exitNode();
@@ -185,7 +185,7 @@ public:
     void advance();
 
     StringView text() const { ASSERT(!atEnd()); return m_text; }
-    PassRefPtr<Range> range() const;
+    WEBCORE_EXPORT PassRefPtr<Range> range() const;
     Node* node() const { ASSERT(!atEnd()); return m_node; }
 
 private:
index 6320ed9..6ce5519 100644 (file)
@@ -53,7 +53,7 @@ public:
     // NOTE: UPSTREAM affinity will be used only if pos is at end of a wrapped line,
     // otherwise it will be converted to DOWNSTREAM
     VisiblePosition() : m_affinity(VP_DEFAULT_AFFINITY) { }
-    VisiblePosition(const Position&, EAffinity = VP_DEFAULT_AFFINITY);
+    WEBCORE_EXPORT VisiblePosition(const Position&, EAffinity = VP_DEFAULT_AFFINITY);
 
     void clear() { m_deepPosition.clear(); }
 
@@ -68,15 +68,15 @@ public:
     // FIXME: Change the following functions' parameter from a boolean to StayInEditableContent.
 
     // next() and previous() will increment/decrement by a character cluster.
-    VisiblePosition next(EditingBoundaryCrossingRule = CanCrossEditingBoundary) const;
-    VisiblePosition previous(EditingBoundaryCrossingRule = CanCrossEditingBoundary) const;
+    WEBCORE_EXPORT VisiblePosition next(EditingBoundaryCrossingRule = CanCrossEditingBoundary) const;
+    WEBCORE_EXPORT VisiblePosition previous(EditingBoundaryCrossingRule = CanCrossEditingBoundary) const;
     VisiblePosition honorEditingBoundaryAtOrBefore(const VisiblePosition&) const;
     VisiblePosition honorEditingBoundaryAtOrAfter(const VisiblePosition&) const;
 
-    VisiblePosition left(bool stayInEditableContent = false) const;
-    VisiblePosition right(bool stayInEditableContent = false) const;
+    WEBCORE_EXPORT VisiblePosition left(bool stayInEditableContent = false) const;
+    WEBCORE_EXPORT VisiblePosition right(bool stayInEditableContent = false) const;
 
-    UChar32 characterAfter() const;
+    WEBCORE_EXPORT UChar32 characterAfter() const;
     UChar32 characterBefore() const { return previous().characterAfter(); }
 
     // FIXME: This does not handle [table, 0] correctly.
@@ -93,12 +93,12 @@ public:
     }
 
     // Rect is local to the returned renderer
-    LayoutRect localCaretRect(RenderObject*&) const;
+    WEBCORE_EXPORT LayoutRect localCaretRect(RenderObject*&) const;
     // Bounds of (possibly transformed) caret in absolute coords
-    IntRect absoluteCaretBounds() const;
+    WEBCORE_EXPORT IntRect absoluteCaretBounds() const;
     // Abs x/y position of the caret ignoring transforms.
     // FIXME: navigation with transforms should be smarter.
-    int lineDirectionPointForBlockDirectionNavigation() const;
+    WEBCORE_EXPORT int lineDirectionPointForBlockDirectionNavigation() const;
     
 #ifndef NDEBUG
     void debugPosition(const char* msg = "") const;
@@ -150,13 +150,13 @@ inline bool operator>=(const VisiblePosition& a, const VisiblePosition& b)
 }    
 #endif
 
-PassRefPtr<Range> makeRange(const VisiblePosition&, const VisiblePosition&);
+WEBCORE_EXPORT PassRefPtr<Range> makeRange(const VisiblePosition&, const VisiblePosition&);
 bool setStart(Range*, const VisiblePosition&);
 bool setEnd(Range*, const VisiblePosition&);
 VisiblePosition startVisiblePosition(const Range*, EAffinity);
 VisiblePosition endVisiblePosition(const Range*, EAffinity);
 
-Element* enclosingBlockFlowElement(const VisiblePosition&);
+WEBCORE_EXPORT Element* enclosingBlockFlowElement(const VisiblePosition&);
 
 bool isFirstVisiblePositionInNode(const VisiblePosition&, const Node*);
 bool isLastVisiblePositionInNode(const VisiblePosition&, const Node*);
index bf0789a..73f616b 100644 (file)
@@ -40,17 +40,17 @@ class VisibleSelection {
 public:
     enum SelectionType { NoSelection, CaretSelection, RangeSelection };
 
-    VisibleSelection();
+    WEBCORE_EXPORT VisibleSelection();
 
     VisibleSelection(const Position&, EAffinity, bool isDirectional = false);
     VisibleSelection(const Position&, const Position&, EAffinity = SEL_DEFAULT_AFFINITY, bool isDirectional = false);
 
-    VisibleSelection(const Range*, EAffinity = SEL_DEFAULT_AFFINITY, bool isDirectional = false);
+    WEBCORE_EXPORT VisibleSelection(const Range*, EAffinity = SEL_DEFAULT_AFFINITY, bool isDirectional = false);
     
-    VisibleSelection(const VisiblePosition&, bool isDirectional = false);
-    VisibleSelection(const VisiblePosition&, const VisiblePosition&, bool isDirectional = false);
+    WEBCORE_EXPORT VisibleSelection(const VisiblePosition&, bool isDirectional = false);
+    WEBCORE_EXPORT VisibleSelection(const VisiblePosition&, const VisiblePosition&, bool isDirectional = false);
 
-    static VisibleSelection selectionFromContentsOfNode(Node*);
+    WEBCORE_EXPORT static VisibleSelection selectionFromContentsOfNode(Node*);
 
     SelectionType selectionType() const { return m_selectionType; }
 
@@ -83,29 +83,29 @@ public:
     bool isDirectional() const { return m_isDirectional; }
     void setIsDirectional(bool isDirectional) { m_isDirectional = isDirectional; }
 
-    bool isAll(EditingBoundaryCrossingRule) const;
+    WEBCORE_EXPORT bool isAll(EditingBoundaryCrossingRule) const;
 
     void appendTrailingWhitespace();
 
-    bool expandUsingGranularity(TextGranularity granularity);
+    WEBCORE_EXPORT bool expandUsingGranularity(TextGranularity granularity);
     
     // We don't yet support multi-range selections, so we only ever have one range to return.
-    PassRefPtr<Range> firstRange() const;
+    WEBCORE_EXPORT PassRefPtr<Range> firstRange() const;
 
     // FIXME: Most callers probably don't want this function, but are using it
     // for historical reasons.  toNormalizedRange contracts the range around
     // text, and moves the caret upstream before returning the range.
-    PassRefPtr<Range> toNormalizedRange() const;
+    WEBCORE_EXPORT PassRefPtr<Range> toNormalizedRange() const;
     
-    Element* rootEditableElement() const;
-    bool isContentEditable() const;
+    WEBCORE_EXPORT Element* rootEditableElement() const;
+    WEBCORE_EXPORT bool isContentEditable() const;
     bool hasEditableStyle() const;
-    bool isContentRichlyEditable() const;
+    WEBCORE_EXPORT bool isContentRichlyEditable() const;
     // Returns a shadow tree node for legacy shadow trees, a child of the
     // ShadowRoot node for new shadow trees, or 0 for non-shadow trees.
     Node* nonBoundaryShadowTreeRootNode() const;
 
-    bool isInPasswordField() const;
+    WEBCORE_EXPORT bool isInPasswordField() const;
 
 #ifndef NDEBUG
     void debugPosition() const;
index 8e6cf6d..d0a7cd2 100644 (file)
@@ -38,41 +38,41 @@ class VisiblePosition;
 enum EWordSide { RightWordIfOnBoundary = false, LeftWordIfOnBoundary = true };
 
 // words
-VisiblePosition startOfWord(const VisiblePosition &, EWordSide = RightWordIfOnBoundary);
-VisiblePosition endOfWord(const VisiblePosition &, EWordSide = RightWordIfOnBoundary);
-VisiblePosition previousWordPosition(const VisiblePosition &);
-VisiblePosition nextWordPosition(const VisiblePosition &);
+WEBCORE_EXPORT VisiblePosition startOfWord(const VisiblePosition &, EWordSide = RightWordIfOnBoundary);
+WEBCORE_EXPORT VisiblePosition endOfWord(const VisiblePosition &, EWordSide = RightWordIfOnBoundary);
+WEBCORE_EXPORT VisiblePosition previousWordPosition(const VisiblePosition &);
+WEBCORE_EXPORT VisiblePosition nextWordPosition(const VisiblePosition &);
 VisiblePosition rightWordPosition(const VisiblePosition&, bool skipsSpaceWhenMovingRight);
 VisiblePosition leftWordPosition(const VisiblePosition&, bool skipsSpaceWhenMovingRight);
 bool isStartOfWord(const VisiblePosition&);
 
 // sentences
-VisiblePosition startOfSentence(const VisiblePosition &);
-VisiblePosition endOfSentence(const VisiblePosition &);
-VisiblePosition previousSentencePosition(const VisiblePosition &);
-VisiblePosition nextSentencePosition(const VisiblePosition &);
+WEBCORE_EXPORT VisiblePosition startOfSentence(const VisiblePosition &);
+WEBCORE_EXPORT VisiblePosition endOfSentence(const VisiblePosition &);
+WEBCORE_EXPORT VisiblePosition previousSentencePosition(const VisiblePosition &);
+WEBCORE_EXPORT VisiblePosition nextSentencePosition(const VisiblePosition &);
 
 // lines
-VisiblePosition startOfLine(const VisiblePosition &);
-VisiblePosition endOfLine(const VisiblePosition &);
-VisiblePosition previousLinePosition(const VisiblePosition&, int lineDirectionPoint, EditableType = ContentIsEditable);
-VisiblePosition nextLinePosition(const VisiblePosition&, int lineDirectionPoint, EditableType = ContentIsEditable);
-bool inSameLine(const VisiblePosition &, const VisiblePosition &);
-bool isStartOfLine(const VisiblePosition &);
-bool isEndOfLine(const VisiblePosition &);
+WEBCORE_EXPORT VisiblePosition startOfLine(const VisiblePosition &);
+WEBCORE_EXPORT VisiblePosition endOfLine(const VisiblePosition &);
+WEBCORE_EXPORT VisiblePosition previousLinePosition(const VisiblePosition&, int lineDirectionPoint, EditableType = ContentIsEditable);
+WEBCORE_EXPORT VisiblePosition nextLinePosition(const VisiblePosition&, int lineDirectionPoint, EditableType = ContentIsEditable);
+WEBCORE_EXPORT bool inSameLine(const VisiblePosition &, const VisiblePosition &);
+WEBCORE_EXPORT bool isStartOfLine(const VisiblePosition &);
+WEBCORE_EXPORT bool isEndOfLine(const VisiblePosition &);
 VisiblePosition logicalStartOfLine(const VisiblePosition &);
 VisiblePosition logicalEndOfLine(const VisiblePosition &);
 VisiblePosition leftBoundaryOfLine(const VisiblePosition&, TextDirection);
 VisiblePosition rightBoundaryOfLine(const VisiblePosition&, TextDirection);
 
 // paragraphs (perhaps a misnomer, can be divided by line break elements)
-VisiblePosition startOfParagraph(const VisiblePosition&, EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
-VisiblePosition endOfParagraph(const VisiblePosition&, EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
+WEBCORE_EXPORT VisiblePosition startOfParagraph(const VisiblePosition&, EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
+WEBCORE_EXPORT VisiblePosition endOfParagraph(const VisiblePosition&, EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
 VisiblePosition startOfNextParagraph(const VisiblePosition&);
-VisiblePosition previousParagraphPosition(const VisiblePosition &, int x);
-VisiblePosition nextParagraphPosition(const VisiblePosition &, int x);
-bool isStartOfParagraph(const VisiblePosition &, EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
-bool isEndOfParagraph(const VisiblePosition &, EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
+WEBCORE_EXPORT VisiblePosition previousParagraphPosition(const VisiblePosition &, int x);
+WEBCORE_EXPORT VisiblePosition nextParagraphPosition(const VisiblePosition &, int x);
+WEBCORE_EXPORT bool isStartOfParagraph(const VisiblePosition &, EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
+WEBCORE_EXPORT bool isEndOfParagraph(const VisiblePosition &, EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
 bool inSameParagraph(const VisiblePosition &, const VisiblePosition &, EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
 
 // blocks (true paragraphs; line break elements don't break blocks)
@@ -83,28 +83,28 @@ bool isStartOfBlock(const VisiblePosition &);
 bool isEndOfBlock(const VisiblePosition &);
 
 // document
-VisiblePosition startOfDocument(const Node*);
-VisiblePosition endOfDocument(const Node*);
-VisiblePosition startOfDocument(const VisiblePosition &);
-VisiblePosition endOfDocument(const VisiblePosition &);
+WEBCORE_EXPORT VisiblePosition startOfDocument(const Node*);
+WEBCORE_EXPORT VisiblePosition endOfDocument(const Node*);
+WEBCORE_EXPORT VisiblePosition startOfDocument(const VisiblePosition &);
+WEBCORE_EXPORT VisiblePosition endOfDocument(const VisiblePosition &);
 bool inSameDocument(const VisiblePosition &, const VisiblePosition &);
-bool isStartOfDocument(const VisiblePosition &);
-bool isEndOfDocument(const VisiblePosition &);
+WEBCORE_EXPORT bool isStartOfDocument(const VisiblePosition &);
+WEBCORE_EXPORT bool isEndOfDocument(const VisiblePosition &);
 
 // editable content
-VisiblePosition startOfEditableContent(const VisiblePosition&);
-VisiblePosition endOfEditableContent(const VisiblePosition&);
-bool isEndOfEditableOrNonEditableContent(const VisiblePosition&);
+WEBCORE_EXPORT VisiblePosition startOfEditableContent(const VisiblePosition&);
+WEBCORE_EXPORT VisiblePosition endOfEditableContent(const VisiblePosition&);
+WEBCORE_EXPORT bool isEndOfEditableOrNonEditableContent(const VisiblePosition&);
 
 #if PLATFORM(IOS)
-bool atBoundaryOfGranularity(const VisiblePosition&, TextGranularity, SelectionDirection);
-bool withinTextUnitOfGranularity(const VisiblePosition&, TextGranularity, SelectionDirection);
-VisiblePosition positionOfNextBoundaryOfGranularity(const VisiblePosition&, TextGranularity, SelectionDirection);
-PassRefPtr<Range> enclosingTextUnitOfGranularity(const VisiblePosition&, TextGranularity, SelectionDirection);
-int distanceBetweenPositions(const VisiblePosition&, const VisiblePosition&);
-PassRefPtr<Range> wordRangeFromPosition(const VisiblePosition& position);
-VisiblePosition closestWordBoundaryForPosition(const VisiblePosition& position);
-void charactersAroundPosition(const VisiblePosition&, UChar32& oneAfter, UChar32& oneBefore, UChar32& twoBefore);
+WEBCORE_EXPORT bool atBoundaryOfGranularity(const VisiblePosition&, TextGranularity, SelectionDirection);
+WEBCORE_EXPORT bool withinTextUnitOfGranularity(const VisiblePosition&, TextGranularity, SelectionDirection);
+WEBCORE_EXPORT VisiblePosition positionOfNextBoundaryOfGranularity(const VisiblePosition&, TextGranularity, SelectionDirection);
+WEBCORE_EXPORT PassRefPtr<Range> enclosingTextUnitOfGranularity(const VisiblePosition&, TextGranularity, SelectionDirection);
+WEBCORE_EXPORT int distanceBetweenPositions(const VisiblePosition&, const VisiblePosition&);
+WEBCORE_EXPORT PassRefPtr<Range> wordRangeFromPosition(const VisiblePosition& position);
+WEBCORE_EXPORT VisiblePosition closestWordBoundaryForPosition(const VisiblePosition& position);
+WEBCORE_EXPORT void charactersAroundPosition(const VisiblePosition&, UChar32& oneAfter, UChar32& oneBefore, UChar32& twoBefore);
 #endif
 } // namespace WebCore
 
index 1eab100..05625b6 100644 (file)
@@ -32,9 +32,9 @@ namespace WebCore {
     
 class Range;
     
-NSAttributedString *attributedStringFromRange(Range&);
+WEBCORE_EXPORT NSAttributedString *attributedStringFromRange(Range&);
 #if !PLATFORM(IOS)
-NSAttributedString *editingAttributedStringFromRange(Range&);
+WEBCORE_EXPORT NSAttributedString *editingAttributedStringFromRange(Range&);
 #endif
 
 }
index e9b674e..54f9738 100644 (file)
@@ -78,7 +78,7 @@ Node* previousLeafNode(const Node*);
 
 // offset functions on Node
 
-int lastOffsetForEditing(const Node*);
+WEBCORE_EXPORT int lastOffsetForEditing(const Node*);
 int caretMinOffset(const Node*);
 int caretMaxOffset(const Node*);
 
@@ -159,7 +159,7 @@ int comparePositions(const Position&, const Position&);
 // boolean functions on Position
 
 enum EUpdateStyle { UpdateStyle, DoNotUpdateStyle };
-bool isEditablePosition(const Position&, EditableType = ContentIsEditable, EUpdateStyle = UpdateStyle);
+WEBCORE_EXPORT bool isEditablePosition(const Position&, EditableType = ContentIsEditable, EUpdateStyle = UpdateStyle);
 bool isRichlyEditablePosition(const Position&, EditableType = ContentIsEditable);
 bool isFirstVisiblePositionInSpecialElement(const Position&);
 bool isLastVisiblePositionInSpecialElement(const Position&);
@@ -198,7 +198,7 @@ VisiblePosition visiblePositionForIndexUsingCharacterIterator(Node*, int index);
     
 // Functions returning HTMLElement
     
-PassRefPtr<HTMLElement> createDefaultParagraphElement(Document&);
+WEBCORE_EXPORT PassRefPtr<HTMLElement> createDefaultParagraphElement(Document&);
 PassRefPtr<HTMLElement> createBreakElement(Document&);
 PassRefPtr<HTMLElement> createOrderedListElement(Document&);
 PassRefPtr<HTMLElement> createUnorderedListElement(Document&);
index 809e1e9..f18b57e 100644 (file)
@@ -37,12 +37,12 @@ namespace WebCore {
 
 #if USE(DICTATION_ALTERNATIVES)
 struct TextAlternativeWithRange {
-    TextAlternativeWithRange(NSTextAlternatives* anAlternatives, NSRange aRange);
+    WEBCORE_EXPORT TextAlternativeWithRange(NSTextAlternatives* anAlternatives, NSRange aRange);
     NSRange range;
     RetainPtr<NSTextAlternatives> alternatives;
 };
 
-void collectDictationTextAlternatives(NSAttributedString*, Vector<TextAlternativeWithRange>& alternatives);
+WEBCORE_EXPORT void collectDictationTextAlternatives(NSAttributedString*, Vector<TextAlternativeWithRange>& alternatives);
 
 #else
 struct TextAlternativeWithRange { };
index 3f65eb3..5d08899 100644 (file)
@@ -39,8 +39,8 @@ extern "C" NSString *NSTextInsertionUndoableAttributeName;
 namespace WebCore {
     
 #if USE(INSERTION_UNDO_GROUPING)
-bool shouldRegisterInsertionUndoGroup(NSAttributedString*);
-void registerInsertionUndoGroupingWithUndoManager(NSUndoManager*);
+WEBCORE_EXPORT bool shouldRegisterInsertionUndoGroup(NSAttributedString*);
+WEBCORE_EXPORT void registerInsertionUndoGroupingWithUndoManager(NSUndoManager*);
 #endif
     
 } // namespace WebCore
index 3981b8c..9e81f7d 100644 (file)
@@ -49,8 +49,8 @@ enum EChildrenOnly { IncludeNode, ChildrenOnly };
 enum EAbsoluteURLs { DoNotResolveURLs, ResolveAllURLs, ResolveNonLocalURLs };
 enum EFragmentSerialization { HTMLFragmentSerialization, XMLFragmentSerialization };
 
-PassRefPtr<DocumentFragment> createFragmentFromText(Range& context, const String& text);
-PassRefPtr<DocumentFragment> createFragmentFromMarkup(Document&, const String& markup, const String& baseURL, ParserContentPolicy = AllowScriptingContent);
+WEBCORE_EXPORT PassRefPtr<DocumentFragment> createFragmentFromText(Range& context, const String& text);
+WEBCORE_EXPORT PassRefPtr<DocumentFragment> createFragmentFromMarkup(Document&, const String& markup, const String& baseURL, ParserContentPolicy = AllowScriptingContent);
 PassRefPtr<DocumentFragment> createFragmentForInnerOuterHTML(const String&, Element*, ParserContentPolicy, ExceptionCode&);
 PassRefPtr<DocumentFragment> createFragmentForTransformToFragment(const String&, const String& sourceMIMEType, Document* outputDoc);
 PassRefPtr<DocumentFragment> createContextualFragment(const String&, HTMLElement*, ParserContentPolicy, ExceptionCode&);
@@ -65,8 +65,8 @@ void replaceChildrenWithText(ContainerNode&, const String&, ExceptionCode&);
 String createMarkup(const Range&, Vector<Node*>* = 0, EAnnotateForInterchange = DoNotAnnotateForInterchange, bool convertBlocksToInlines = false, EAbsoluteURLs = DoNotResolveURLs);
 String createMarkup(const Node&, EChildrenOnly = IncludeNode, Vector<Node*>* = 0, EAbsoluteURLs = DoNotResolveURLs, Vector<QualifiedName>* tagNamesToSkip = 0, EFragmentSerialization = HTMLFragmentSerialization);
 
-String createFullMarkup(const Node&);
-String createFullMarkup(const Range&);
+WEBCORE_EXPORT String createFullMarkup(const Node&);
+WEBCORE_EXPORT String createFullMarkup(const Range&);
 
 String urlToMarkup(const URL&, const String& title);
 
index 550ed91..b2154ea 100644 (file)
@@ -53,7 +53,7 @@ static void defaultNotifyHistoryItemChanged(HistoryItem*)
 {
 }
 
-void (*notifyHistoryItemChanged)(HistoryItem*) = defaultNotifyHistoryItemChanged;
+WEBCORE_EXPORT void (*notifyHistoryItemChanged)(HistoryItem*) = defaultNotifyHistoryItemChanged;
 
 HistoryItem::HistoryItem()
     : m_pageScaleFactor(0)
index d6fda29..62ca7e6 100644 (file)
@@ -94,7 +94,7 @@ namespace WebCore {
      };
 
     // Function to obtain the global page cache.
-    PageCache* pageCache();
+    WEBCORE_EXPORT PageCache* pageCache();
 
 } // namespace WebCore
 
index 7190731..b43e251 100644 (file)
@@ -38,31 +38,31 @@ typedef int ExceptionCode;
 
 class TimeRanges : public RefCounted<TimeRanges> {
 public:
-    static PassRefPtr<TimeRanges> create();
-    static PassRefPtr<TimeRanges> create(double start, double end);
+    WEBCORE_EXPORT static PassRefPtr<TimeRanges> create();
+    WEBCORE_EXPORT static PassRefPtr<TimeRanges> create(double start, double end);
     static PassRefPtr<TimeRanges> create(const PlatformTimeRanges&);
 
-    double start(unsigned index, ExceptionCode&) const;
-    double end(unsigned index, ExceptionCode&) const;
+    WEBCORE_EXPORT double start(unsigned index, ExceptionCode&) const;
+    WEBCORE_EXPORT double end(unsigned index, ExceptionCode&) const;
 
-    PassRefPtr<TimeRanges> copy() const;
+    WEBCORE_EXPORT PassRefPtr<TimeRanges> copy() const;
     void invert();
-    void intersectWith(const TimeRanges&);
+    WEBCORE_EXPORT void intersectWith(const TimeRanges&);
     void unionWith(const TimeRanges&);
     
-    unsigned length() const;
+    WEBCORE_EXPORT unsigned length() const;
 
-    void add(double start, double end);
+    WEBCORE_EXPORT void add(double start, double end);
     bool contain(double time) const;
     
     size_t find(double time) const;
-    double nearest(double time) const;
+    WEBCORE_EXPORT double nearest(double time) const;
     double totalDuration() const;
 
     const PlatformTimeRanges& ranges() const { return m_ranges; }
 
 private:
-    explicit TimeRanges();
+    WEBCORE_EXPORT explicit TimeRanges();
     TimeRanges(double start, double end);
     TimeRanges(const PlatformTimeRanges&);
 
index da3bd7b..9df11de 100644 (file)
@@ -39,7 +39,7 @@ bool isNotHTMLSpace(UChar);
 bool isHTMLSpaceButNotLineBreak(UChar character);
 
 // Strip leading and trailing whitespace as defined by the HTML specification. 
-String stripLeadingAndTrailingHTMLSpaces(const String&);
+WEBCORE_EXPORT String stripLeadingAndTrailingHTMLSpaces(const String&);
 template<size_t inlineCapacity>
 String stripLeadingAndTrailingHTMLSpaces(const Vector<UChar, inlineCapacity>& vector)
 {
index 0d990aa..ed80a06 100644 (file)
@@ -173,7 +173,7 @@ private:
     InspectorWorkerAgent* m_inspectorWorkerAgent;
 };
 
-InstrumentingAgents* instrumentationForPage(Page*);
+WEBCORE_EXPORT InstrumentingAgents* instrumentationForPage(Page*);
 InstrumentingAgents* instrumentationForWorkerGlobalScope(WorkerGlobalScope*);
 
 }
index 7619f22..e48951b 100644 (file)
@@ -80,7 +80,7 @@ class SubstituteData;
 struct FrameLoadRequest;
 struct WindowFeatures;
 
-bool isBackForwardLoadType(FrameLoadType);
+WEBCORE_EXPORT bool isBackForwardLoadType(FrameLoadType);
 
 class FrameLoader {
     WTF_MAKE_NONCOPYABLE(FrameLoader);
index 4143fee..9efea6f 100644 (file)
@@ -47,13 +47,13 @@ public:
     static PassRefPtr<ResourceBuffer> create(const char* data, unsigned size) { return adoptRef(new ResourceBuffer(data, size)); }
     static PassRefPtr<ResourceBuffer> adoptSharedBuffer(PassRefPtr<SharedBuffer>);
 
-    virtual ~ResourceBuffer();
+    WEBCORE_EXPORT virtual ~ResourceBuffer();
 
-    virtual const char* data() const;
-    virtual unsigned size() const;
-    virtual bool isEmpty() const;
+    WEBCORE_EXPORT virtual const char* data() const;
+    WEBCORE_EXPORT virtual unsigned size() const;
+    WEBCORE_EXPORT virtual bool isEmpty() const;
 
-    void append(const char*, unsigned);
+    WEBCORE_EXPORT void append(const char*, unsigned);
     void append(SharedBuffer*);
 #if USE(NETWORK_CFDATA_ARRAY_CALLBACK)
     void append(CFDataRef);
@@ -62,14 +62,14 @@ public:
     
     unsigned getSomeData(const char*& data, unsigned position = 0) const;
     
-    SharedBuffer* sharedBuffer() const;
+    WEBCORE_EXPORT SharedBuffer* sharedBuffer() const;
 #if USE(FOUNDATION)
     void tryReplaceSharedBufferContents(SharedBuffer*);
 #endif
     PassRefPtr<ResourceBuffer> copy() const;
 
 #if USE(FOUNDATION)
-    RetainPtr<NSData> createNSData();
+    WEBCORE_EXPORT RetainPtr<NSData> createNSData();
 #endif
 #if USE(CF)
     RetainPtr<CFDataRef> createCFData();
@@ -79,10 +79,10 @@ public:
 #endif
 
 protected:
-    ResourceBuffer();
+    WEBCORE_EXPORT ResourceBuffer();
 
 private:
-    ResourceBuffer(const char*, unsigned);
+    WEBCORE_EXPORT ResourceBuffer(const char*, unsigned);
     ResourceBuffer(PassRefPtr<SharedBuffer>);
 
     RefPtr<SharedBuffer> m_sharedBuffer;
index 9b4f3ef..c05b3b4 100644 (file)
@@ -50,15 +50,15 @@ class ResourceLoadScheduler {
 public:
     friend ResourceLoadScheduler* resourceLoadScheduler();
 
-    virtual PassRefPtr<SubresourceLoader> scheduleSubresourceLoad(Frame*, CachedResource*, const ResourceRequest&, ResourceLoadPriority, const ResourceLoaderOptions&);
-    virtual PassRefPtr<NetscapePlugInStreamLoader> schedulePluginStreamLoad(Frame*, NetscapePlugInStreamLoaderClient*, const ResourceRequest&);
-    virtual void remove(ResourceLoader*);
+    WEBCORE_EXPORT virtual PassRefPtr<SubresourceLoader> scheduleSubresourceLoad(Frame*, CachedResource*, const ResourceRequest&, ResourceLoadPriority, const ResourceLoaderOptions&);
+    WEBCORE_EXPORT virtual PassRefPtr<NetscapePlugInStreamLoader> schedulePluginStreamLoad(Frame*, NetscapePlugInStreamLoaderClient*, const ResourceRequest&);
+    WEBCORE_EXPORT virtual void remove(ResourceLoader*);
     virtual void setDefersLoading(ResourceLoader*, bool);
     virtual void crossOriginRedirectReceived(ResourceLoader*, const URL& redirectURL);
     
-    virtual void servePendingRequests(ResourceLoadPriority minimumPriority = ResourceLoadPriorityVeryLow);
-    virtual void suspendPendingRequests();
-    virtual void resumePendingRequests();
+    WEBCORE_EXPORT virtual void servePendingRequests(ResourceLoadPriority minimumPriority = ResourceLoadPriorityVeryLow);
+    WEBCORE_EXPORT virtual void suspendPendingRequests();
+    WEBCORE_EXPORT virtual void resumePendingRequests();
     
     bool isSerialLoadingEnabled() const { return m_isSerialLoadingEnabled; }
     virtual void setSerialLoadingEnabled(bool b) { m_isSerialLoadingEnabled = b; }
@@ -72,13 +72,13 @@ public:
     };
 
 protected:
-    ResourceLoadScheduler();
-    virtual ~ResourceLoadScheduler();
+    WEBCORE_EXPORT ResourceLoadScheduler();
+    WEBCORE_EXPORT virtual ~ResourceLoadScheduler();
 
-    void notifyDidScheduleResourceRequest(ResourceLoader*);
+    WEBCORE_EXPORT void notifyDidScheduleResourceRequest(ResourceLoader*);
 
 #if USE(QUICK_LOOK)
-    bool maybeLoadQuickLookResource(ResourceLoader&);
+    WEBCORE_EXPORT bool maybeLoadQuickLookResource(ResourceLoader&);
 #endif
 
 private:
@@ -118,7 +118,7 @@ private:
     };
     
     HostInformation* hostForURL(const URL&, CreateHostPolicy = FindOnly);
-    void servePendingRequests(HostInformation*, ResourceLoadPriority);
+    WEBCORE_EXPORT void servePendingRequests(HostInformation*, ResourceLoadPriority);
 
     typedef HashMap<String, HostInformation*, StringHash> HostMap;
     HostMap m_hosts;
@@ -130,7 +130,7 @@ private:
     bool m_isSerialLoadingEnabled;
 };
 
-ResourceLoadScheduler* resourceLoadScheduler();
+WEBCORE_EXPORT ResourceLoadScheduler* resourceLoadScheduler();
 
 }
 
index e3128a2..aa34913 100644 (file)
@@ -57,7 +57,7 @@ class ResourceLoader : public RefCounted<ResourceLoader>, protected ResourceHand
 public:
     virtual ~ResourceLoader() = 0;
 
-    void cancel();
+    WEBCORE_EXPORT void cancel();
 
     virtual bool init(const ResourceRequest&);
 
@@ -71,12 +71,12 @@ public:
     virtual const ResourceRequest& iOSOriginalRequest() const { return request(); }
 #endif
 
-    FrameLoader* frameLoader() const;
+    WEBCORE_EXPORT FrameLoader* frameLoader() const;
     DocumentLoader* documentLoader() const { return m_documentLoader.get(); }
-    const ResourceRequest& originalRequest() const { return m_originalRequest; }
+    WEBCORE_EXPORT const ResourceRequest& originalRequest() const { return m_originalRequest; }
     
-    void cancel(const ResourceError&);
-    ResourceError cancelledError();
+    WEBCORE_EXPORT void cancel(const ResourceError&);
+    WEBCORE_EXPORT ResourceError cancelledError();
     ResourceError blockedError();
     ResourceError cannotShowURLError();
     
@@ -107,7 +107,7 @@ public:
 
     virtual bool shouldUseCredentialStorage();
     virtual void didReceiveAuthenticationChallenge(const AuthenticationChallenge&);
-    void didCancelAuthenticationChallenge(const AuthenticationChallenge&);
+    WEBCORE_EXPORT void didCancelAuthenticationChallenge(const AuthenticationChallenge&);
 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
     virtual bool canAuthenticateAgainstProtectionSpace(const ProtectionSpace&);
 #endif
index e20ca54..a599082 100644 (file)
@@ -65,7 +65,7 @@ public:
 
     PassRefPtr<Widget> createJavaAppletWidget(const IntSize&, HTMLAppletElement&, const Vector<String>& paramNames, const Vector<String>& paramValues);
 
-    bool allowPlugins(ReasonForCallingAllowPlugins);
+    WEBCORE_EXPORT bool allowPlugins(ReasonForCallingAllowPlugins);
 
     bool containsPlugins() const { return m_containsPlugins; }
     
index a43534f..303ffd9 100644 (file)
@@ -44,7 +44,7 @@ class ResourceRequest;
 
 class SubresourceLoader final : public ResourceLoader {
 public:
-    static PassRefPtr<SubresourceLoader> create(Frame*, CachedResource*, const ResourceRequest&, const ResourceLoaderOptions&);
+    WEBCORE_EXPORT static PassRefPtr<SubresourceLoader> create(Frame*, CachedResource*, const ResourceRequest&, const ResourceLoaderOptions&);
 
     virtual ~SubresourceLoader();
 
index abee7d1..c674711 100644 (file)
@@ -47,15 +47,15 @@ public:
     {
         return adoptRef(new TextResourceDecoder(mimeType, defaultEncoding, usesEncodingDetector));
     }
-    ~TextResourceDecoder();
+    WEBCORE_EXPORT ~TextResourceDecoder();
 
     void setEncoding(const TextEncoding&, EncodingSource);
     const TextEncoding& encoding() const { return m_encoding; }
 
-    String decode(const char* data, size_t length);
-    String flush();
+    WEBCORE_EXPORT String decode(const char* data, size_t length);
+    WEBCORE_EXPORT String flush();
 
-    String decodeAndFlush(const char* data, size_t length);
+    WEBCORE_EXPORT String decodeAndFlush(const char* data, size_t length);
 
     void setHintEncoding(const TextResourceDecoder* hintDecoder)
     {
@@ -69,7 +69,7 @@ public:
     bool sawError() const { return m_sawError; }
 
 private:
-    TextResourceDecoder(const String& mimeType, const TextEncoding& defaultEncoding, bool usesEncodingDetector);
+    WEBCORE_EXPORT TextResourceDecoder(const String& mimeType, const TextEncoding& defaultEncoding, bool usesEncodingDetector);
 
     enum ContentType { PlainText, HTML, XML, CSS }; // PlainText only checks for BOM.
     static ContentType determineContentType(const String& mimeType);
index 57a545f..a943fdb 100644 (file)
@@ -150,7 +150,7 @@ private:
     friend class WTF::NeverDestroyed<ApplicationCacheStorage>;
 };
 
-ApplicationCacheStorage& cacheStorage();
+WEBCORE_EXPORT ApplicationCacheStorage& cacheStorage();
 
 } // namespace WebCore
 
index f6684ba..12503e0 100644 (file)
@@ -247,7 +247,7 @@ private:
 };
 
 // Function to obtain the global cache.
-MemoryCache* memoryCache();
+WEBCORE_EXPORT MemoryCache* memoryCache();
 
 }
 
index 16bcbc6..f289577 100644 (file)
@@ -213,8 +213,8 @@ public:
 };
 
 // Functions to get/set the global icon database.
-IconDatabaseBase& iconDatabase();
-void setGlobalIconDatabase(IconDatabaseBase*);
+WEBCORE_EXPORT IconDatabaseBase& iconDatabase();
+WEBCORE_EXPORT void setGlobalIconDatabase(IconDatabaseBase*);
 bool documentCanHaveIcon(const String&);
 
 } // namespace WebCore
index c694f8e..45e1999 100644 (file)
@@ -138,7 +138,7 @@ private:
 };
 
 // Function to obtain the global disk image cache.
-DiskImageCache& diskImageCache();
+WEBCORE_EXPORT DiskImageCache& diskImageCache();
 
 } // namespace WebCore
 
index 3acdd5e..fca7f90 100644 (file)
@@ -156,8 +156,8 @@ public:
 
     WEBCORE_EXPORT void print(Frame*);
 
-    void enableSuddenTermination();
-    void disableSuddenTermination();
+    WEBCORE_EXPORT void enableSuddenTermination();
+    WEBCORE_EXPORT void disableSuddenTermination();
 
 #if ENABLE(INPUT_TYPE_COLOR)
     PassOwnPtr<ColorChooser> createColorChooser(ColorChooserClient*, const Color& initialColor);
index 43b471a..744c9d8 100644 (file)
@@ -50,17 +50,17 @@ public:
         BlockAllStorage
     };
 
-    static PassRefPtr<SecurityOrigin> create(const URL&);
+    WEBCORE_EXPORT static PassRefPtr<SecurityOrigin> create(const URL&);
     static PassRefPtr<SecurityOrigin> createUnique();
 
-    static PassRefPtr<SecurityOrigin> createFromDatabaseIdentifier(const String&);
+    WEBCORE_EXPORT static PassRefPtr<SecurityOrigin> createFromDatabaseIdentifier(const String&);
     // Alternate form of createFromDatabaseIdentifier that returns a nullptr on failure, instead of an empty origin.
     // FIXME: Many users of createFromDatabaseIdentifier seem to expect maybeCreateFromDatabaseIdentifier behavior,
     // but they aren't getting it so they might be buggy.
-    static PassRefPtr<SecurityOrigin> maybeCreateFromDatabaseIdentifier(const String&);
+    WEBCORE_EXPORT static PassRefPtr<SecurityOrigin> maybeCreateFromDatabaseIdentifier(const String&);
 
-    static PassRefPtr<SecurityOrigin> createFromString(const String&);
-    static PassRefPtr<SecurityOrigin> create(const String& protocol, const String& host, int port);
+    WEBCORE_EXPORT static PassRefPtr<SecurityOrigin> createFromString(const String&);
+    WEBCORE_EXPORT static PassRefPtr<SecurityOrigin> create(const String& protocol, const String& host, int port);
 
     // Some URL schemes use nested URLs for their security context. For example,
     // filesystem URLs look like the following:
@@ -77,7 +77,7 @@ public:
 
     // Create a deep copy of this SecurityOrigin. This method is useful
     // when marshalling a SecurityOrigin to another thread.
-    PassRefPtr<SecurityOrigin> isolatedCopy() const;
+    WEBCORE_EXPORT PassRefPtr<SecurityOrigin> isolatedCopy() const;
 
     // Set the domain property of this security origin to newDomain. This
     // function does not check whether newDomain is a suffix of the current
@@ -99,7 +99,7 @@ public:
     // SecurityOrigin. For example, call this function before allowing
     // script from one security origin to read or write objects from
     // another SecurityOrigin.
-    bool canAccess(const SecurityOrigin*) const;
+    WEBCORE_EXPORT bool canAccess(const SecurityOrigin*) const;
 
     // Returns true if this SecurityOrigin can read content retrieved from
     // the given URL. For example, call this function before issuing
@@ -119,7 +119,7 @@ public:
     // Returns true if |document| can display content from the given URL (e.g.,
     // in an iframe or as an image). For example, web sites generally cannot
     // display content from the user's files system.
-    bool canDisplay(const URL&) const;
+    WEBCORE_EXPORT bool canDisplay(const URL&) const;
 
     // Returns true if this SecurityOrigin can load local resources, such
     // as images, iframes, and style sheets, and can link to local URLs.
@@ -147,7 +147,7 @@ public:
     void setStorageBlockingPolicy(StorageBlockingPolicy policy) { m_storageBlockingPolicy = policy; }
 
 #if ENABLE(CACHE_PARTITIONING)
-    String cachePartition() const;
+    WEBCORE_EXPORT String cachePartition() const;
 #endif
 
     bool canAccessDatabase(const SecurityOrigin* topOrigin = 0) const { return canAccessStorage(topOrigin); };
@@ -189,26 +189,26 @@ public:
     // this SecurityOrigin might have come from a sandboxed iframe, the
     // SecurityOrigin might be empty, or we might have explicitly decided that
     // we shouldTreatURLSchemeAsNoAccess.
-    String toString() const;
+    WEBCORE_EXPORT String toString() const;
 
     // Similar to toString(), but does not take into account any factors that
     // could make the string return "null".
-    String toRawString() const;
+    WEBCORE_EXPORT String toRawString() const;
 
     // Serialize the security origin to a string that could be used as part of
     // file names. This format should be used in storage APIs only.
-    String databaseIdentifier() const;
+    WEBCORE_EXPORT String databaseIdentifier() const;
 
     // This method checks for equality between SecurityOrigins, not whether
     // one origin can access another. It is used for hash table keys.
     // For access checks, use canAccess().
     // FIXME: If this method is really only useful for hash table keys, it
     // should be refactored into SecurityOriginHash.
-    bool equal(const SecurityOrigin*) const;
+    WEBCORE_EXPORT bool equal(const SecurityOrigin*) const;
 
     // This method checks for equality, ignoring the value of document.domain
     // (and whether it was set) but considering the host. It is used for postMessage.
-    bool isSameSchemeHostPort(const SecurityOrigin*) const;
+    WEBCORE_EXPORT bool isSameSchemeHostPort(const SecurityOrigin*) const;
 
     static URL urlWithUniqueSecurityOrigin();
 
@@ -226,7 +226,7 @@ private:
     bool isHTTPFamily() const { return m_protocol == "http" || m_protocol == "https"; }
     
     enum ShouldAllowFromThirdParty { AlwaysAllowFromThirdParty, MaybeAllowFromThirdParty };
-    bool canAccessStorage(const SecurityOrigin*, ShouldAllowFromThirdParty = MaybeAllowFromThirdParty) const;
+    WEBCORE_EXPORT bool canAccessStorage(const SecurityOrigin*, ShouldAllowFromThirdParty = MaybeAllowFromThirdParty) const;
 
     String m_protocol;
     String m_host;
index b269c1a..487f12c 100644 (file)
@@ -42,7 +42,7 @@ public:
     // True if the referrer should be omitted according to the
     // ReferrerPolicyDefault. If you intend to send a referrer header, you
     // should use generateReferrerHeader instead.
-    static bool shouldHideReferrer(const URL&, const String& referrer);
+    WEBCORE_EXPORT static bool shouldHideReferrer(const URL&, const String& referrer);
 
     // Returns the referrer modified according to the referrer policy for a
     // navigation to a given URL. If the referrer returned is empty, the
@@ -55,13 +55,13 @@ public:
         AllowLocalLoadsForLocalOnly,
     };
 
-    static void setLocalLoadPolicy(LocalLoadPolicy);
+    WEBCORE_EXPORT static void setLocalLoadPolicy(LocalLoadPolicy);
     static bool restrictAccessToLocal();
     static bool allowSubstituteDataAccessToLocal();
 
-    static void addOriginAccessWhitelistEntry(const SecurityOrigin& sourceOrigin, const String& destinationProtocol, const String& destinationDomain, bool allowDestinationSubdomains);
-    static void removeOriginAccessWhitelistEntry(const SecurityOrigin& sourceOrigin, const String& destinationProtocol, const String& destinationDomain, bool allowDestinationSubdomains);
-    static void resetOriginAccessWhitelists();
+    WEBCORE_EXPORT static void addOriginAccessWhitelistEntry(const SecurityOrigin& sourceOrigin, const String& destinationProtocol, const String& destinationDomain, bool allowDestinationSubdomains);
+    WEBCORE_EXPORT static void removeOriginAccessWhitelistEntry(const SecurityOrigin& sourceOrigin, const String& destinationProtocol, const String& destinationDomain, bool allowDestinationSubdomains);
+    WEBCORE_EXPORT static void resetOriginAccessWhitelists();
 
     static bool isAccessWhiteListed(const SecurityOrigin* activeOrigin, const SecurityOrigin* targetOrigin);
     static bool isAccessToURLWhiteListed(const SecurityOrigin* activeOrigin, const URL&);
index ba283ea..a3a0147 100644 (file)
@@ -66,26 +66,26 @@ public:
     static PassRefPtr<Settings> create(Page*);
     ~Settings();
 
-    void setStandardFontFamily(const AtomicString&, UScriptCode = USCRIPT_COMMON);
-    const AtomicString& standardFontFamily(UScriptCode = USCRIPT_COMMON) const;
+    WEBCORE_EXPORT void setStandardFontFamily(const AtomicString&, UScriptCode = USCRIPT_COMMON);
+    WEBCORE_EXPORT const AtomicString& standardFontFamily(UScriptCode = USCRIPT_COMMON) const;
 
-    void setFixedFontFamily(const AtomicString&, UScriptCode = USCRIPT_COMMON);
-    const AtomicString& fixedFontFamily(UScriptCode = USCRIPT_COMMON) const;
+    WEBCORE_EXPORT void setFixedFontFamily(const AtomicString&, UScriptCode = USCRIPT_COMMON);
+    WEBCORE_EXPORT const AtomicString& fixedFontFamily(UScriptCode = USCRIPT_COMMON) const;
 
-    void setSerifFontFamily(const AtomicString&, UScriptCode = USCRIPT_COMMON);
-    const AtomicString& serifFontFamily(UScriptCode = USCRIPT_COMMON) const;
+    WEBCORE_EXPORT void setSerifFontFamily(const AtomicString&, UScriptCode = USCRIPT_COMMON);
+    WEBCORE_EXPORT const AtomicString& serifFontFamily(UScriptCode = USCRIPT_COMMON) const;
 
-    void setSansSerifFontFamily(const AtomicString&, UScriptCode = USCRIPT_COMMON);
-    const AtomicString& sansSerifFontFamily(UScriptCode = USCRIPT_COMMON) const;
+    WEBCORE_EXPORT void setSansSerifFontFamily(const AtomicString&, UScriptCode = USCRIPT_COMMON);
+    WEBCORE_EXPORT const AtomicString& sansSerifFontFamily(UScriptCode = USCRIPT_COMMON) const;
 
-    void setCursiveFontFamily(const AtomicString&, UScriptCode = USCRIPT_COMMON);
-    const AtomicString& cursiveFontFamily(UScriptCode = USCRIPT_COMMON) const;
+    WEBCORE_EXPORT void setCursiveFontFamily(const AtomicString&, UScriptCode = USCRIPT_COMMON);
+    WEBCORE_EXPORT const AtomicString& cursiveFontFamily(UScriptCode = USCRIPT_COMMON) const;
 
-    void setFantasyFontFamily(const AtomicString&, UScriptCode = USCRIPT_COMMON);
-    const AtomicString& fantasyFontFamily(UScriptCode = USCRIPT_COMMON) const;
+    WEBCORE_EXPORT void setFantasyFontFamily(const AtomicString&, UScriptCode = USCRIPT_COMMON);
+    WEBCORE_EXPORT const AtomicString& fantasyFontFamily(UScriptCode = USCRIPT_COMMON) const;
 
-    void setPictographFontFamily(const AtomicString&, UScriptCode = USCRIPT_COMMON);
-    const AtomicString& pictographFontFamily(UScriptCode = USCRIPT_COMMON) const;
+    WEBCORE_EXPORT void setPictographFontFamily(const AtomicString&, UScriptCode = USCRIPT_COMMON);
+    WEBCORE_EXPORT const AtomicString& pictographFontFamily(UScriptCode = USCRIPT_COMMON) const;
 
 #if ENABLE(TEXT_AUTOSIZING)
     void setTextAutosizingEnabled(bool);
@@ -100,36 +100,36 @@ public:
 #endif
 
     // Only set by Layout Tests.
-    void setMediaTypeOverride(const String&);
+    WEBCORE_EXPORT void setMediaTypeOverride(const String&);
     const String& mediaTypeOverride() const { return m_mediaTypeOverride; }
 
     // Unlike areImagesEnabled, this only suppresses the network load of
     // the image URL.  A cached image will still be rendered if requested.
-    void setLoadsImagesAutomatically(bool);
+    WEBCORE_EXPORT void setLoadsImagesAutomatically(bool);
     bool loadsImagesAutomatically() const { return m_loadsImagesAutomatically; }
 
     // Clients that execute script should call ScriptController::canExecuteScripts()
     // instead of this function. ScriptController::canExecuteScripts() checks the
     // HTML sandbox, plug-in sandboxing, and other important details.
     bool isScriptEnabled() const { return m_isScriptEnabled; }
-    void setScriptEnabled(bool);
+    WEBCORE_EXPORT void setScriptEnabled(bool);
 
     SETTINGS_GETTERS_AND_SETTERS
 
-    void setScreenFontSubstitutionEnabled(bool);
+    WEBCORE_EXPORT void setScreenFontSubstitutionEnabled(bool);
     bool screenFontSubstitutionEnabled() const { return m_screenFontSubstitutionEnabled; }
 
-    void setJavaEnabled(bool);
+    WEBCORE_EXPORT void setJavaEnabled(bool);
     bool isJavaEnabled() const { return m_isJavaEnabled; }
 
     // This settings is only consulted if isJavaEnabled() returns true;
-    void setJavaEnabledForLocalFiles(bool);
+    WEBCORE_EXPORT void setJavaEnabledForLocalFiles(bool);
     bool isJavaEnabledForLocalFiles() const { return m_isJavaEnabledForLocalFiles; }
 
-    void setImagesEnabled(bool);
+    WEBCORE_EXPORT void setImagesEnabled(bool);
     bool areImagesEnabled() const { return m_areImagesEnabled; }
 
-    void setPluginsEnabled(bool);
+    WEBCORE_EXPORT void setPluginsEnabled(bool);
     bool arePluginsEnabled() const { return m_arePluginsEnabled; }
 
     // When this option is set, WebCore will avoid storing any record of browsing activity
@@ -147,26 +147,26 @@ public:
     //  - Plug-ins (that support NPNVprivateModeBool)
     void setPrivateBrowsingEnabled(bool);
 
-    void setDNSPrefetchingEnabled(bool);
+    WEBCORE_EXPORT void setDNSPrefetchingEnabled(bool);
     bool dnsPrefetchingEnabled() const { return m_dnsPrefetchingEnabled; }
 
-    void setUserStyleSheetLocation(const URL&);
+    WEBCORE_EXPORT void setUserStyleSheetLocation(const URL&);
     const URL& userStyleSheetLocation() const { return m_userStyleSheetLocation; }
 
-    void setNeedsAdobeFrameReloadingQuirk(bool);
+    WEBCORE_EXPORT void setNeedsAdobeFrameReloadingQuirk(bool);
     bool needsAcrobatFrameReloadingQuirk() const { return m_needsAdobeFrameReloadingQuirk; }
 
-    static void setDefaultMinDOMTimerInterval(double); // Interval specified in seconds.
-    static double defaultMinDOMTimerInterval();
+    WEBCORE_EXPORT static void setDefaultMinDOMTimerInterval(double); // Interval specified in seconds.
+    WEBCORE_EXPORT static double defaultMinDOMTimerInterval();
         
     static void setHiddenPageDOMTimerAlignmentInterval(double); // Interval specified in seconds.
     static double hiddenPageDOMTimerAlignmentInterval();
 
-    void setMinDOMTimerInterval(double); // Per-page; initialized to default value.
-    double minDOMTimerInterval();
+    WEBCORE_EXPORT void setMinDOMTimerInterval(double); // Per-page; initialized to default value.
+    WEBCORE_EXPORT double minDOMTimerInterval();
 
     static void setDefaultDOMTimerAlignmentInterval(double);
-    static double defaultDOMTimerAlignmentInterval();
+    WEBCORE_EXPORT static double defaultDOMTimerAlignmentInterval();
 
     double domTimerAlignmentInterval() const;
 
@@ -175,16 +175,16 @@ public:
 
 #if ENABLE(HIDDEN_PAGE_DOM_TIMER_THROTTLING)
     bool hiddenPageDOMTimerThrottlingEnabled() const { return m_hiddenPageDOMTimerThrottlingEnabled; }
-    void setHiddenPageDOMTimerThrottlingEnabled(bool);
+    WEBCORE_EXPORT void setHiddenPageDOMTimerThrottlingEnabled(bool);
 #endif
 
-    void setUsesPageCache(bool);
+    WEBCORE_EXPORT void setUsesPageCache(bool);
     bool usesPageCache() const { return m_usesPageCache; }
         
     void setFontRenderingMode(FontRenderingMode mode);
     FontRenderingMode fontRenderingMode() const;
 
-    void setShowTiledScrollingIndicator(bool);
+    WEBCORE_EXPORT void setShowTiledScrollingIndicator(bool);
     bool showTiledScrollingIndicator() const { return m_showTiledScrollingIndicator; }
 
 #if PLATFORM(WIN)
@@ -192,16 +192,16 @@ public:
     static bool shouldUseHighResolutionTimers() { return gShouldUseHighResolutionTimers; }
 #endif
 
-    void setBackgroundShouldExtendBeyondPage(bool);
+    WEBCORE_EXPORT void setBackgroundShouldExtendBeyondPage(bool);
     bool backgroundShouldExtendBeyondPage() const { return m_backgroundShouldExtendBeyondPage; }
 
 #if USE(AVFOUNDATION)
-    static void setAVFoundationEnabled(bool flag);
+    WEBCORE_EXPORT static void setAVFoundationEnabled(bool flag);
     static bool isAVFoundationEnabled() { return gAVFoundationEnabled; }
 #endif
 
 #if PLATFORM(COCOA)
-    static void setQTKitEnabled(bool flag);
+    WEBCORE_EXPORT static void setQTKitEnabled(bool flag);
     static bool isQTKitEnabled() { return gQTKitEnabled; }
 #endif
 
@@ -213,10 +213,10 @@ public:
     static bool shouldPaintNativeControls() { return gShouldPaintNativeControls; }
 #endif
 
-    static void setMockScrollbarsEnabled(bool flag);
-    static bool mockScrollbarsEnabled();
+    WEBCORE_EXPORT static void setMockScrollbarsEnabled(bool flag);
+    WEBCORE_EXPORT static bool mockScrollbarsEnabled();
 
-    static void setUsesOverlayScrollbars(bool flag);
+    WEBCORE_EXPORT static void setUsesOverlayScrollbars(bool flag);
     static bool usesOverlayScrollbars();
 
 #if ENABLE(TOUCH_EVENTS)
@@ -224,35 +224,35 @@ public:
     bool isTouchEventEmulationEnabled() const { return m_touchEventEmulationEnabled; }
 #endif
 
-    void setStorageBlockingPolicy(SecurityOrigin::StorageBlockingPolicy);
+    WEBCORE_EXPORT void setStorageBlockingPolicy(SecurityOrigin::StorageBlockingPolicy);
     SecurityOrigin::StorageBlockingPolicy storageBlockingPolicy() const { return m_storageBlockingPolicy; }
 
-    void setScrollingPerformanceLoggingEnabled(bool);
+    WEBCORE_EXPORT void setScrollingPerformanceLoggingEnabled(bool);
     bool scrollingPerformanceLoggingEnabled() { return m_scrollingPerformanceLoggingEnabled; }
 
-    static void setShouldRespectPriorityInCSSAttributeSetters(bool);
+    WEBCORE_EXPORT static void setShouldRespectPriorityInCSSAttributeSetters(bool);
     static bool shouldRespectPriorityInCSSAttributeSetters();
 
     void setTimeWithoutMouseMovementBeforeHidingControls(double time) { m_timeWithoutMouseMovementBeforeHidingControls = time; }
     double timeWithoutMouseMovementBeforeHidingControls() const { return m_timeWithoutMouseMovementBeforeHidingControls; }
 
     bool hiddenPageCSSAnimationSuspensionEnabled() const { return m_hiddenPageCSSAnimationSuspensionEnabled; }
-    void setHiddenPageCSSAnimationSuspensionEnabled(bool);
+    WEBCORE_EXPORT void setHiddenPageCSSAnimationSuspensionEnabled(bool);
 
-    void setFontFallbackPrefersPictographs(bool);
+    WEBCORE_EXPORT void setFontFallbackPrefersPictographs(bool);
     bool fontFallbackPrefersPictographs() const { return m_fontFallbackPrefersPictographs; }
 
     static bool lowPowerVideoAudioBufferSizeEnabled() { return gLowPowerVideoAudioBufferSizeEnabled; }
-    static void setLowPowerVideoAudioBufferSizeEnabled(bool);
+    WEBCORE_EXPORT static void setLowPowerVideoAudioBufferSizeEnabled(bool);
 
 #if PLATFORM(IOS)
-    static void setAudioSessionCategoryOverride(unsigned);
+    WEBCORE_EXPORT static void setAudioSessionCategoryOverride(unsigned);
     static unsigned audioSessionCategoryOverride();
 
-    static void setNetworkDataUsageTrackingEnabled(bool);
+    WEBCORE_EXPORT static void setNetworkDataUsageTrackingEnabled(bool);
     static bool networkDataUsageTrackingEnabled();
 
-    static void setNetworkInterfaceName(const String&);
+    WEBCORE_EXPORT static void setNetworkInterfaceName(const String&);
     static const String& networkInterfaceName();
 
     static void setAVKitEnabled(bool flag) { gAVKitEnabled = flag; }
@@ -320,11 +320,11 @@ private:
     static double gDefaultDOMTimerAlignmentInterval;
 
 #if USE(AVFOUNDATION)
-    static bool gAVFoundationEnabled;
+    WEBCORE_EXPORT static bool gAVFoundationEnabled;
 #endif
 
 #if PLATFORM(COCOA)
-    static bool gQTKitEnabled;
+    WEBCORE_EXPORT static bool gQTKitEnabled;
 #endif
         
     static bool gMockScrollbarsEnabled;
@@ -339,9 +339,9 @@ private:
     static bool gShouldRespectPriorityInCSSAttributeSetters;
 #if PLATFORM(IOS)
     static bool gNetworkDataUsageTrackingEnabled;
-    static bool gAVKitEnabled;
-    static bool gShouldOptOutOfNetworkStateObservation;
-    static bool gManageAudioSession;
+    WEBCORE_EXPORT static bool gAVKitEnabled;
+    WEBCORE_EXPORT static bool gShouldOptOutOfNetworkStateObservation;
+    WEBCORE_EXPORT static bool gManageAudioSession;
 #endif
 
     static double gHiddenPageDOMTimerAlignmentInterval;
index 1eba86e..b28b603 100644 (file)
@@ -47,31 +47,31 @@ class UserMessageHandlerDescriptor;
 
 class UserContentController : public RefCounted<UserContentController> {
 public:
-    static RefPtr<UserContentController> create();
-    ~UserContentController();
+    WEBCORE_EXPORT static RefPtr<UserContentController> create();
+    WEBCORE_EXPORT ~UserContentController();
 
     void addPage(Page&);
     void removePage(Page&);
 
     const UserScriptMap* userScripts() const { return m_userScripts.get(); }
 
-    void addUserScript(DOMWrapperWorld&, std::unique_ptr<UserScript>);
+    WEBCORE_EXPORT void addUserScript(DOMWrapperWorld&, std::unique_ptr<UserScript>);
     void removeUserScript(DOMWrapperWorld&, const URL&);
-    void removeUserScripts(DOMWrapperWorld&);
+    WEBCORE_EXPORT void removeUserScripts(DOMWrapperWorld&);
 
     const UserStyleSheetMap* userStyleSheets() const { return m_userStyleSheets.get(); }
 
-    void addUserStyleSheet(DOMWrapperWorld&, std::unique_ptr<UserStyleSheet>, UserStyleInjectionTime);
+    WEBCORE_EXPORT void addUserStyleSheet(DOMWrapperWorld&, std::unique_ptr<UserStyleSheet>, UserStyleInjectionTime);
     void removeUserStyleSheet(DOMWrapperWorld&, const URL&);
-    void removeUserStyleSheets(DOMWrapperWorld&);
+    WEBCORE_EXPORT void removeUserStyleSheets(DOMWrapperWorld&);
 
     void removeAllUserContent();
 
 #if ENABLE(USER_MESSAGE_HANDLERS)
     const UserMessageHandlerDescriptorMap* userMessageHandlerDescriptors() const { return m_userMessageHandlerDescriptors.get(); }
 
-    void addUserMessageHandlerDescriptor(UserMessageHandlerDescriptor&);
-    void removeUserMessageHandlerDescriptor(UserMessageHandlerDescriptor&);
+    WEBCORE_EXPORT void addUserMessageHandlerDescriptor(UserMessageHandlerDescriptor&);
+    WEBCORE_EXPORT void removeUserMessageHandlerDescriptor(UserMessageHandlerDescriptor&);
 #endif
 
 private:
index 38d0681..8b8af6d 100644 (file)
@@ -45,7 +45,7 @@ public:
 
     bool isValid() const { return !m_invalid; }
 
-    bool matches(const URL&) const;
+    WEBCORE_EXPORT bool matches(const URL&) const;
 
     const String& scheme() const { return m_scheme; }
     const String& host() const { return m_host; }
@@ -56,7 +56,7 @@ public:
     static bool matchesPatterns(const URL&, const Vector<String>& whitelist, const Vector<String>& blacklist);
 
 private:
-    bool parse(const String& pattern);
+    WEBCORE_EXPORT bool parse(const String& pattern);
 
     bool matchesHost(const URL&) const;
     bool matchesPath(const URL&) const;
index 7bc5cec..644bae7 100644 (file)
@@ -52,7 +52,7 @@ public:
     {
         return adoptRef(new UserMessageHandlerDescriptor(name, world, client));
     }
-    ~UserMessageHandlerDescriptor();
+    WEBCORE_EXPORT ~UserMessageHandlerDescriptor();
 
     const AtomicString& name();
     DOMWrapperWorld& world();
@@ -60,7 +60,7 @@ public:
     Client& client() const { return m_client; }
 
 private:
-    explicit UserMessageHandlerDescriptor(const AtomicString&, DOMWrapperWorld&, Client&);
+    WEBCORE_EXPORT explicit UserMessageHandlerDescriptor(const AtomicString&, DOMWrapperWorld&, Client&);
     
     AtomicString m_name;
     Ref<DOMWrapperWorld> m_world;
index ba45ca2..632d2b4 100644 (file)
@@ -63,40 +63,40 @@ public:
         bool initialScaleIsSet;
     };
 
-    ViewportConfiguration();
+    WEBCORE_EXPORT ViewportConfiguration();
 
     const Parameters& defaultConfiguration() const { return m_defaultConfiguration; }
-    void setDefaultConfiguration(const Parameters&);
+    WEBCORE_EXPORT void setDefaultConfiguration(const Parameters&);
 
     const IntSize& contentsSize() const { return m_contentSize; }
-    void setContentsSize(const IntSize&);
+    WEBCORE_EXPORT void setContentsSize(const IntSize&);
 
     const FloatSize& minimumLayoutSize() const { return m_minimumLayoutSize; }
-    void setMinimumLayoutSize(const FloatSize&);
+    WEBCORE_EXPORT void setMinimumLayoutSize(const FloatSize&);
 
     const FloatSize& minimumLayoutSizeForMinimalUI() const { return m_minimumLayoutSizeForMinimalUI.isEmpty() ? m_minimumLayoutSize : m_minimumLayoutSizeForMinimalUI; }
-    void setMinimumLayoutSizeForMinimalUI(const FloatSize&);
+    WEBCORE_EXPORT void setMinimumLayoutSizeForMinimalUI(const FloatSize&);
 
-    const FloatSize& activeMinimumLayoutSizeInScrollViewCoordinates() const;
+    WEBCORE_EXPORT const FloatSize& activeMinimumLayoutSizeInScrollViewCoordinates() const;
 
     const ViewportArguments& viewportArguments() const { return m_viewportArguments; }
-    void setViewportArguments(const ViewportArguments&);
+    WEBCORE_EXPORT void setViewportArguments(const ViewportArguments&);
 
-    void resetMinimalUI();
-    void didFinishDocumentLoad();
+    WEBCORE_EXPORT void resetMinimalUI();
+    WEBCORE_EXPORT void didFinishDocumentLoad();
 
-    IntSize layoutSize() const;
-    double initialScale() const;
-    double minimumScale() const;
+    WEBCORE_EXPORT IntSize layoutSize() const;
+    WEBCORE_EXPORT double initialScale() const;
+    WEBCORE_EXPORT double minimumScale() const;
     double maximumScale() const { return m_configuration.maximumScale; }
     bool allowsUserScaling() const { return m_configuration.allowsUserScaling; }
     bool usesMinimalUI() const { return m_usesMinimalUI; }
 
-    static Parameters webpageParameters();
-    static Parameters textDocumentParameters();
-    static Parameters imageDocumentParameters();
-    static Parameters xhtmlMobileParameters();
-    static Parameters testingParameters();
+    WEBCORE_EXPORT static Parameters webpageParameters();
+    WEBCORE_EXPORT static Parameters textDocumentParameters();
+    WEBCORE_EXPORT static Parameters imageDocumentParameters();
+    WEBCORE_EXPORT static Parameters xhtmlMobileParameters();
+    WEBCORE_EXPORT static Parameters testingParameters();
     
 #ifndef NDEBUG
     WTF::CString description() const;
index fc9d765..3e4703c 100644 (file)
@@ -39,8 +39,8 @@ class URL;
 
 class VisitedLinkStore : public RefCounted<VisitedLinkStore> {
 public:
-    VisitedLinkStore();
-    virtual ~VisitedLinkStore();
+    WEBCORE_EXPORT VisitedLinkStore();
+    WEBCORE_EXPORT virtual ~VisitedLinkStore();
 
     // FIXME: These two members should only take the link hash.
     virtual bool isLinkVisited(Page&, LinkHash, const URL& baseURL, const AtomicString& attributeURL) = 0;
@@ -49,8 +49,8 @@ public:
     void addPage(Page&);
     void removePage(Page&);
 
-    void invalidateStylesForAllLinks();
-    void invalidateStylesForLink(LinkHash);
+    WEBCORE_EXPORT void invalidateStylesForAllLinks();
+    WEBCORE_EXPORT void invalidateStylesForLink(LinkHash);
 
 private:
     HashSet<Page*> m_pages;
index cb4ab09..652d03f 100644 (file)
@@ -44,16 +44,16 @@ enum class DominantScrollGestureDirection {
 
 class WheelEventDeltaTracker {
 public:
-    WheelEventDeltaTracker();
+    WEBCORE_EXPORT WheelEventDeltaTracker();
     virtual ~WheelEventDeltaTracker();
 
-    void beginTrackingDeltas();
-    void endTrackingDeltas();
+    WEBCORE_EXPORT void beginTrackingDeltas();
+    WEBCORE_EXPORT void endTrackingDeltas();
 
     bool isTrackingDeltas() const { return m_isTrackingDeltas; }
 
-    void recordWheelEventDelta(const PlatformWheelEvent&);
-    DominantScrollGestureDirection dominantScrollGestureDirection() const;
+    WEBCORE_EXPORT void recordWheelEventDelta(const PlatformWheelEvent&);
+    WEBCORE_EXPORT DominantScrollGestureDirection dominantScrollGestureDirection() const;
 
 private:
     Deque<FloatSize> m_recentWheelEventDeltas;
index 172d23b..1e01a29 100644 (file)
@@ -30,7 +30,7 @@
 
 namespace WebCore {
 
-String standardUserAgentWithApplicationName(const String& applicationName, const String& webkitVersionString);
+WEBCORE_EXPORT String standardUserAgentWithApplicationName(const String& applicationName, const String& webkitVersionString);
 
 String systemMarketingVersionForUserAgentString();
 String userAgentBundleVersionFromFullVersionString(const String&);
index e2d5bd3..ea799ac 100644 (file)
@@ -137,7 +137,7 @@ public:
     const FloatSize stickyOffsetAtLastLayout() const { return m_stickyOffsetAtLastLayout; }
     void setStickyOffsetAtLastLayout(const FloatSize& offset) { m_stickyOffsetAtLastLayout = offset; }
 
-    FloatPoint layerPositionForConstrainingRect(const FloatRect& constrainingRect) const;
+    WEBCORE_EXPORT FloatPoint layerPositionForConstrainingRect(const FloatRect& constrainingRect) const;
 
     const FloatPoint& layerPositionAtLastLayout() const { return m_layerPositionAtLastLayout; }
     void setLayerPositionAtLastLayout(const FloatPoint& point) { m_layerPositionAtLastLayout = point; }
index c0d8e73..167fdbe 100644 (file)
@@ -108,7 +108,7 @@ public:
     static PassRefPtr<ScrollingCoordinator> create(Page*);
     virtual ~ScrollingCoordinator();
 
-    virtual void pageDestroyed();
+    WEBCORE_EXPORT virtual void pageDestroyed();
     
     virtual bool isAsyncScrollingCoordinator() const { return false; }
     virtual bool isRemoteScrollingCoordinator() const { return false; }
@@ -150,7 +150,7 @@ public:
 #endif
 
     // Force all scroll layer position updates to happen on the main thread.
-    void setForceSynchronousScrollLayerPositionUpdates(bool);
+    WEBCORE_EXPORT void setForceSynchronousScrollLayerPositionUpdates(bool);
 
     // These virtual functions are currently unique to the threaded scrolling architecture. 
     // Their meaningful implementations are in ScrollingCoordinatorMac.
index 0b1e9f6..b474faf 100644 (file)
@@ -49,7 +49,7 @@ public:
         ViewportConstraints = NumStateNodeBits
     };
 
-    void updateConstraints(const FixedPositionViewportConstraints&);
+    WEBCORE_EXPORT void updateConstraints(const FixedPositionViewportConstraints&);
     const FixedPositionViewportConstraints& viewportConstraints() const { return m_constraints; }
 
 private:
index 11e980c..12235b1 100644 (file)
@@ -65,53 +65,53 @@ public:
     };
 
     float frameScaleFactor() const { return m_frameScaleFactor; }
-    void setFrameScaleFactor(float);
+    WEBCORE_EXPORT void setFrameScaleFactor(float);
 
     const Region& nonFastScrollableRegion() const { return m_nonFastScrollableRegion; }
-    void setNonFastScrollableRegion(const Region&);
+    WEBCORE_EXPORT void setNonFastScrollableRegion(const Region&);
 
     unsigned wheelEventHandlerCount() const { return m_wheelEventHandlerCount; }
-    void setWheelEventHandlerCount(unsigned);
+    WEBCORE_EXPORT void setWheelEventHandlerCount(unsigned);
 
     SynchronousScrollingReasons synchronousScrollingReasons() const { return m_synchronousScrollingReasons; }
-    void setSynchronousScrollingReasons(SynchronousScrollingReasons);
+    WEBCORE_EXPORT void setSynchronousScrollingReasons(SynchronousScrollingReasons);
 
     ScrollBehaviorForFixedElements scrollBehaviorForFixedElements() const { return m_behaviorForFixed; }
-    void setScrollBehaviorForFixedElements(ScrollBehaviorForFixedElements);
+    WEBCORE_EXPORT void setScrollBehaviorForFixedElements(ScrollBehaviorForFixedElements);
 
     int headerHeight() const { return m_headerHeight; }
-    void setHeaderHeight(int);
+    WEBCORE_EXPORT void setHeaderHeight(int);
 
     int footerHeight() const { return m_footerHeight; }
-    void setFooterHeight(int);
+    WEBCORE_EXPORT void setFooterHeight(int);
 
     float topContentInset() const { return m_topContentInset; }
-    void setTopContentInset(float);
+    WEBCORE_EXPORT void setTopContentInset(float);
 
     const LayerRepresentation& scrolledContentsLayer() const { return m_scrolledContentsLayer; }
-    void setScrolledContentsLayer(const LayerRepresentation&);
+    WEBCORE_EXPORT void setScrolledContentsLayer(const LayerRepresentation&);
 
     // This is a layer moved in the opposite direction to scrolling, for example for background-attachment:fixed
     const LayerRepresentation& counterScrollingLayer() const { return m_counterScrollingLayer; }
-    void setCounterScrollingLayer(const LayerRepresentation&);
+    WEBCORE_EXPORT void setCounterScrollingLayer(const LayerRepresentation&);
 
     // This is a clipping layer that will scroll with the page for all y-delta scroll values between 0
     // and topContentInset(). Once the y-deltas get beyond the content inset point, this layer no longer
     // needs to move. If the topContentInset() is 0, this layer does not need to move at all. This is
     // only used on the Mac.
     const LayerRepresentation& insetClipLayer() const { return m_insetClipLayer; }
-    void setInsetClipLayer(const LayerRepresentation&);
+    WEBCORE_EXPORT void setInsetClipLayer(const LayerRepresentation&);
 
     const LayerRepresentation& contentShadowLayer() const { return m_contentShadowLayer; }
-    void setContentShadowLayer(const LayerRepresentation&);
+    WEBCORE_EXPORT void setContentShadowLayer(const LayerRepresentation&);
 
     // The header and footer layers scroll vertically with the page, they should remain fixed when scrolling horizontally.
     const LayerRepresentation& headerLayer() const { return m_headerLayer; }
-    void setHeaderLayer(const LayerRepresentation&);
+    WEBCORE_EXPORT void setHeaderLayer(const LayerRepresentation&);
 
     // The header and footer layers scroll vertically with the page, they should remain fixed when scrolling horizontally.
     const LayerRepresentation& footerLayer() const { return m_footerLayer; }
-    void setFooterLayer(const LayerRepresentation&);
+    WEBCORE_EXPORT void setFooterLayer(const LayerRepresentation&);
 
 #if PLATFORM(MAC)
     ScrollbarPainter verticalScrollbarPainter() const { return m_verticalScrollbarPainter.get(); }
index 902ee2d..68ff7b0 100644 (file)
@@ -218,7 +218,7 @@ public:
     virtual void syncLayerPositionForViewportRect(const LayoutRect& /*viewportRect*/) { }
 
     const LayerRepresentation& layer() const { return m_layer; }
-    void setLayer(const LayerRepresentation&);
+    WEBCORE_EXPORT void setLayer(const LayerRepresentation&);
 
     ScrollingStateTree& scrollingStateTree() const { return m_scrollingStateTree; }
 
index af09892..f152003 100644 (file)
@@ -46,7 +46,7 @@ public:
 
     // This is a layer with the contents that move.
     const LayerRepresentation& scrolledContentsLayer() const { return m_scrolledContentsLayer; }
-    void setScrolledContentsLayer(const LayerRepresentation&);
+    WEBCORE_EXPORT void setScrolledContentsLayer(const LayerRepresentation&);
     
     virtual void dumpProperties(TextStream&, int indent) const override;
 
index eb9cd9b..30e708c 100644 (file)
@@ -55,19 +55,19 @@ public:
     };
 
     const FloatSize& scrollableAreaSize() const { return m_scrollableAreaSize; }
-    void setScrollableAreaSize(const FloatSize&);
+    WEBCORE_EXPORT void setScrollableAreaSize(const FloatSize&);
 
     const FloatSize& totalContentsSize() const { return m_totalContentsSize; }
-    void setTotalContentsSize(const FloatSize&);
+    WEBCORE_EXPORT void setTotalContentsSize(const FloatSize&);
 
     const FloatSize& reachableContentsSize() const { return m_reachableContentsSize; }
-    void setReachableContentsSize(const FloatSize&);
+    WEBCORE_EXPORT void setReachableContentsSize(const FloatSize&);
 
     const FloatPoint& scrollPosition() const { return m_scrollPosition; }
-    void setScrollPosition(const FloatPoint&);
+    WEBCORE_EXPORT void setScrollPosition(const FloatPoint&);
 
     const IntPoint& scrollOrigin() const { return m_scrollOrigin; }
-    void setScrollOrigin(const IntPoint&);
+    WEBCORE_EXPORT void setScrollOrigin(const IntPoint&);
 
 #if ENABLE(CSS_SCROLL_SNAP)
     const Vector<float>& horizontalSnapOffsets() const { return m_horizontalSnapOffsets; }
@@ -78,11 +78,11 @@ public:
 #endif
 
     const ScrollableAreaParameters& scrollableAreaParameters() const { return m_scrollableAreaParameters; }
-    void setScrollableAreaParameters(const ScrollableAreaParameters& params);
+    WEBCORE_EXPORT void setScrollableAreaParameters(const ScrollableAreaParameters& params);
 
     const FloatPoint& requestedScrollPosition() const { return m_requestedScrollPosition; }
     bool requestedScrollPositionRepresentsProgrammaticScroll() const { return m_requestedScrollPositionRepresentsProgrammaticScroll; }
-    void setRequestedScrollPosition(const FloatPoint&, bool representsProgrammaticScroll);
+    WEBCORE_EXPORT void setRequestedScrollPosition(const FloatPoint&, bool representsProgrammaticScroll);
     
     virtual void dumpProperties(TextStream&, int indent) const override;
     
index 1d6cbdb..66b8b65 100644 (file)
@@ -49,7 +49,7 @@ public:
         ViewportConstraints = NumStateNodeBits
     };
 
-    void updateConstraints(const StickyPositionViewportConstraints&);
+    WEBCORE_EXPORT void updateConstraints(const StickyPositionViewportConstraints&);
     const StickyPositionViewportConstraints& viewportConstraints() const { return m_constraints; }
 
 private:
index 1e271a7..a14428b 100644 (file)
@@ -46,23 +46,23 @@ class ScrollingStateTree {
     friend class ScrollingStateNode;
 public:
     
-    static PassOwnPtr<ScrollingStateTree> create(AsyncScrollingCoordinator* = 0);
-    ~ScrollingStateTree();
+    WEBCORE_EXPORT static PassOwnPtr<ScrollingStateTree> create(AsyncScrollingCoordinator* = 0);
+    WEBCORE_EXPORT ~ScrollingStateTree();
 
     ScrollingStateFrameScrollingNode* rootStateNode() const { return m_rootStateNode.get(); }
-    ScrollingStateNode* stateNodeForID(ScrollingNodeID);
+    WEBCORE_EXPORT ScrollingStateNode* stateNodeForID(ScrollingNodeID);
 
-    ScrollingNodeID attachNode(ScrollingNodeType, ScrollingNodeID, ScrollingNodeID parentID);
+    WEBCORE_EXPORT ScrollingNodeID attachNode(ScrollingNodeType, ScrollingNodeID, ScrollingNodeID parentID);
     void detachNode(ScrollingNodeID);
     void clear();
     
     const HashSet<ScrollingNodeID>& removedNodes() const { return m_nodesRemovedSinceLastCommit; }
-    void setRemovedNodes(HashSet<ScrollingNodeID>);
+    WEBCORE_EXPORT void setRemovedNodes(HashSet<ScrollingNodeID>);
 
     // Copies the current tree state and clears the changed properties mask in the original.
-    PassOwnPtr<ScrollingStateTree> commit(LayerRepresentation::Type preferredLayerRepresentation);
+    WEBCORE_EXPORT PassOwnPtr<ScrollingStateTree> commit(LayerRepresentation::Type preferredLayerRepresentation);
 
-    void setHasChangedProperties(bool = true);
+    WEBCORE_EXPORT void setHasChangedProperties(bool = true);
     bool hasChangedProperties() const { return m_hasChangedProperties; }
 
     bool hasNewRootStateNode() const { return m_hasNewRootStateNode; }
index a2ca5fc..7f1368e 100644 (file)
@@ -46,11 +46,11 @@ class ScrollingThread {
 
 public:
     static bool isCurrentThread();
-    static void dispatch(std::function<void ()>);
+    WEBCORE_EXPORT static void dispatch(std::function<void ()>);
 
     // Will dispatch the given function on the main thread once all pending functions
     // on the scrolling thread have finished executing. Used for synchronization purposes.
-    static void dispatchBarrier(std::function<void ()>);
+    WEBCORE_EXPORT static void dispatchBarrier(std::function<void ()>);
 
 private:
     friend NeverDestroyed<ScrollingThread>;
index a6a9f27..0d9b468 100644 (file)
@@ -47,8 +47,8 @@ class ScrollingTreeScrollingNode;
 
 class ScrollingTree : public ThreadSafeRefCounted<ScrollingTree> {
 public:
-    ScrollingTree();
-    virtual ~ScrollingTree();
+    WEBCORE_EXPORT ScrollingTree();
+    WEBCORE_EXPORT virtual ~ScrollingTree();
 
     enum EventResult {
         DidNotHandleEvent,
@@ -61,13 +61,13 @@ public:
     virtual bool isScrollingTreeIOS() const { return false; }
 
     virtual EventResult tryToHandleWheelEvent(const PlatformWheelEvent&) = 0;
-    bool shouldHandleWheelEventSynchronously(const PlatformWheelEvent&);
+    WEBCORE_EXPORT bool shouldHandleWheelEventSynchronously(const PlatformWheelEvent&);
     
     void setMainFrameIsRubberBanding(bool);
     bool isRubberBandInProgress();
 
     virtual void invalidate() { }
-    virtual void commitNewTreeState(PassOwnPtr<ScrollingStateTree>);
+    WEBCORE_EXPORT virtual void commitNewTreeState(PassOwnPtr<ScrollingStateTree>);
 
     void setMainFramePinState(bool pinnedToTheLeft, bool pinnedToTheRight, bool pinnedToTheTop, bool pinnedToTheBottom);
 
@@ -82,11 +82,11 @@ public:
 
     // Delegated scrolling/zooming has caused the viewport to change, so update viewport-constrained layers
     // (but don't cause scroll events to be fired).
-    virtual void viewportChangedViaDelegatedScrolling(ScrollingNodeID, const WebCore::FloatRect& fixedPositionRect, double scale);
+    WEBCORE_EXPORT virtual void viewportChangedViaDelegatedScrolling(ScrollingNodeID, const WebCore::FloatRect& fixedPositionRect, double scale);
 
     // Delegated scrolling has scrolled a node. Update layer positions on descendant tree nodes,
     // and call scrollingTreeNodeDidScroll().
-    virtual void scrollPositionChangedViaDelegatedScrolling(ScrollingNodeID, const WebCore::FloatPoint& scrollPosition, bool inUserInteration);
+    WEBCORE_EXPORT virtual void scrollPositionChangedViaDelegatedScrolling(ScrollingNodeID, const WebCore::FloatPoint& scrollPosition, bool inUserInteration);
 
     FloatPoint mainFrameScrollPosition();
     
@@ -97,14 +97,14 @@ public:
     virtual void scrollingTreeNodeDidEndScroll() { }
 #endif
 
-    bool isPointInNonFastScrollableRegion(IntPoint);
+    WEBCORE_EXPORT bool isPointInNonFastScrollableRegion(IntPoint);
     
 #if PLATFORM(MAC)
     virtual void handleWheelEventPhase(PlatformWheelEventPhase) = 0;
 #endif
 
     // Can be called from any thread. Will update what edges allow rubber-banding.
-    void setCanRubberBandState(bool canRubberBandAtLeft, bool canRubberBandAtRight, bool canRubberBandAtTop, bool canRubberBandAtBottom);
+    WEBCORE_EXPORT void setCanRubberBandState(bool canRubberBandAtLeft, bool canRubberBandAtRight, bool canRubberBandAtTop, bool canRubberBandAtBottom);
 
     bool rubberBandsAtLeft();
     bool rubberBandsAtRight();
@@ -115,9 +115,9 @@ public:
     void setScrollPinningBehavior(ScrollPinningBehavior);
     ScrollPinningBehavior scrollPinningBehavior();
 
-    bool willWheelEventStartSwipeGesture(const PlatformWheelEvent&);
+    WEBCORE_EXPORT bool willWheelEventStartSwipeGesture(const PlatformWheelEvent&);
 
-    void setScrollingPerformanceLoggingEnabled(bool flag);
+    WEBCORE_EXPORT void setScrollingPerformanceLoggingEnabled(bool flag);
     bool scrollingPerformanceLoggingEnabled();
 
     ScrollingTreeNode* rootNode() const { return m_rootNode.get(); }
@@ -139,7 +139,7 @@ public:
     
 protected:
     void setMainFrameScrollPosition(FloatPoint);
-    virtual void handleWheelEvent(const PlatformWheelEvent&);
+    WEBCORE_EXPORT virtual void handleWheelEvent(const PlatformWheelEvent&);
 
 private:
     void removeDestroyedNodes(const ScrollingStateTree&);
index f51885f..9451ead 100644 (file)
@@ -34,11 +34,11 @@ namespace WebCore {
 
 class ScrollingTreeOverflowScrollingNode : public ScrollingTreeScrollingNode {
 public:
-    virtual ~ScrollingTreeOverflowScrollingNode();
+    WEBCORE_EXPORT virtual ~ScrollingTreeOverflowScrollingNode();
 
     
 protected:
-    ScrollingTreeOverflowScrollingNode(ScrollingTree&, ScrollingNodeID);
+    WEBCORE_EXPORT ScrollingTreeOverflowScrollingNode(ScrollingTree&, ScrollingNodeID);
 };
 
 SCROLLING_NODE_TYPE_CASTS(ScrollingTreeOverflowScrollingNode, isOverflowScrollingNode());
index 7aaa96e..1fbc598 100644 (file)
@@ -43,14 +43,14 @@ class ScrollingTreeScrollingNode : public ScrollingTreeNode {
 public:
     virtual ~ScrollingTreeScrollingNode();
 
-    virtual void updateBeforeChildren(const ScrollingStateNode&) override;
-    virtual void updateAfterChildren(const ScrollingStateNode&) override;
+    WEBCORE_EXPORT virtual void updateBeforeChildren(const ScrollingStateNode&) override;
+    WEBCORE_EXPORT virtual void updateAfterChildren(const ScrollingStateNode&) override;
 
-    virtual void updateLayersAfterAncestorChange(const ScrollingTreeNode& changedNode, const FloatRect& fixedPositionRect, const FloatSize& cumulativeDelta) override;
+    WEBCORE_EXPORT virtual void updateLayersAfterAncestorChange(const ScrollingTreeNode& changedNode, const FloatRect& fixedPositionRect, const FloatSize& cumulativeDelta) override;
 
     virtual void handleWheelEvent(const PlatformWheelEvent&) = 0;
-    virtual void setScrollPosition(const FloatPoint&);
-    virtual void setScrollPositionWithoutContentEdgeConstraints(const FloatPoint&);
+    WEBCORE_EXPORT virtual void setScrollPosition(const FloatPoint&);
+    WEBCORE_EXPORT virtual void setScrollPositionWithoutContentEdgeConstraints(const FloatPoint&);
 
     virtual void updateLayersAfterViewportChange(const FloatRect& fixedPositionRect, double scale) = 0;
     virtual void updateLayersAfterDelegatedScroll(const FloatPoint&) { }
@@ -65,8 +65,8 @@ public:
 protected:
     ScrollingTreeScrollingNode(ScrollingTree&, ScrollingNodeType, ScrollingNodeID);
 
-    virtual FloatPoint minimumScrollPosition() const;
-    virtual FloatPoint maximumScrollPosition() const;
+    WEBCORE_EXPORT virtual FloatPoint minimumScrollPosition() const;
+    WEBCORE_EXPORT virtual FloatPoint maximumScrollPosition() const;
 
     virtual void setScrollLayerPosition(const FloatPoint&) = 0;
 
index d4d3f47..4dc9eba 100644 (file)
@@ -37,7 +37,7 @@ namespace WebCore {
 
 class ScrollingTreeFrameScrollingNodeIOS : public ScrollingTreeFrameScrollingNode {
 public:
-    static PassRefPtr<ScrollingTreeFrameScrollingNodeIOS> create(ScrollingTree&, ScrollingNodeID);
+    WEBCORE_EXPORT static PassRefPtr<ScrollingTreeFrameScrollingNodeIOS> create(ScrollingTree&, ScrollingNodeID);
     virtual ~ScrollingTreeFrameScrollingNodeIOS();
 
 protected:
index 3143a07..98c1690 100644 (file)
@@ -40,7 +40,7 @@ class FixedPositionViewportConstraints;
 
 class ScrollingTreeFixedNode : public ScrollingTreeNode {
 public:
-    static PassRefPtr<ScrollingTreeFixedNode> create(ScrollingTree&, ScrollingNodeID);
+    WEBCORE_EXPORT static PassRefPtr<ScrollingTreeFixedNode> create(ScrollingTree&, ScrollingNodeID);
 
     virtual ~ScrollingTreeFixedNode();
 
index 0edd29d..64fd745 100644 (file)
@@ -39,7 +39,7 @@ namespace WebCore {
 
 class ScrollingTreeFrameScrollingNodeMac : public ScrollingTreeFrameScrollingNode, private ScrollElasticityControllerClient {
 public:
-    static PassRefPtr<ScrollingTreeFrameScrollingNode> create(ScrollingTree&, ScrollingNodeID);
+    WEBCORE_EXPORT static PassRefPtr<ScrollingTreeFrameScrollingNode> create(ScrollingTree&, ScrollingNodeID);
     virtual ~ScrollingTreeFrameScrollingNodeMac();
 
 private:
index 11a3614..a92a31e 100644 (file)
@@ -40,7 +40,7 @@ class StickyPositionViewportConstraints;
 
 class ScrollingTreeStickyNode : public ScrollingTreeNode {
 public:
-    static PassRefPtr<ScrollingTreeStickyNode> create(ScrollingTree&, ScrollingNodeID);
+    WEBCORE_EXPORT static PassRefPtr<ScrollingTreeStickyNode> create(ScrollingTree&, ScrollingNodeID);
 
     virtual ~ScrollingTreeStickyNode();
 
index daff017..43de224 100644 (file)
@@ -183,11 +183,11 @@ namespace WebCore {
 
     IntPoint determineHotSpot(Image*, const IntPoint& specifiedHotSpot);
     
-    const Cursor& pointerCursor();
+    WEBCORE_EXPORT const Cursor& pointerCursor();
     const Cursor& crossCursor();
-    const Cursor& handCursor();
+    WEBCORE_EXPORT const Cursor& handCursor();
     const Cursor& moveCursor();
-    const Cursor& iBeamCursor();
+    WEBCORE_EXPORT const Cursor& iBeamCursor();
     const Cursor& waitCursor();
     const Cursor& helpCursor();
     const Cursor& eastResizeCursor();
index 9179839..c811c30 100644 (file)
@@ -81,7 +81,7 @@ DragImageRef createDragImageFromImage(Image*, ImageOrientationDescription);
 DragImageRef createDragImageIconForCachedImageFilename(const String&);
 
 DragImageRef createDragImageForNode(Frame&, Node&);
-DragImageRef createDragImageForSelection(Frame&, bool forceBlackText = false);
+WEBCORE_EXPORT DragImageRef createDragImageForSelection(Frame&, bool forceBlackText = false);
 DragImageRef createDragImageForRange(Frame&, Range&, bool forceBlackText = false);
 DragImageRef createDragImageForImage(Frame&, Node&, IntRect& imageRect, IntRect& elementRect);
 DragImageRef createDragImageForLink(URL&, const String& label, FontRenderingMode);
index 3fddf48..43cf876 100644 (file)
@@ -134,27 +134,27 @@ static const char PlatformFilePathSeparator = '/';
 
 struct FileMetadata;
 
-bool fileExists(const String&);
-bool deleteFile(const String&);
-bool deleteEmptyDirectory(const String&);
+WEBCORE_EXPORT bool fileExists(const String&);
+WEBCORE_EXPORT bool deleteFile(const String&);
+WEBCORE_EXPORT bool deleteEmptyDirectory(const String&);
 bool getFileSize(const String&, long long& result);
-bool getFileModificationTime(const String&, time_t& result);
-bool getFileCreationTime(const String&, time_t& result); // Not all platforms store file creation time.
+WEBCORE_EXPORT bool getFileModificationTime(const String&, time_t& result);
+WEBCORE_EXPORT bool getFileCreationTime(const String&, time_t& result); // Not all platforms store file creation time.
 bool getFileMetadata(const String&, FileMetadata&);
-String pathByAppendingComponent(const String& path, const String& component);
-bool makeAllDirectories(const String& path);
+WEBCORE_EXPORT String pathByAppendingComponent(const String& path, const String& component);
+WEBCORE_EXPORT bool makeAllDirectories(const String& path);
 String homeDirectoryPath();
-String pathGetFileName(const String&);
-String directoryName(const String&);
+WEBCORE_EXPORT String pathGetFileName(const String&);
+WEBCORE_EXPORT String directoryName(const String&);
 
-void setMetadataURL(String& URLString, const String& referrer, const String& path);
+WEBCORE_EXPORT void setMetadataURL(String& URLString, const String& referrer, const String& path);
 
 bool canExcludeFromBackup(); // Returns true if any file can ever be excluded from backup.
 bool excludeFromBackup(const String&); // Returns true if successful.
 
-Vector<String> listDirectory(const String& path, const String& filter = String());
+WEBCORE_EXPORT Vector<String> listDirectory(const String& path, const String& filter = String());
 
-CString fileSystemRepresentation(const String&);
+WEBCORE_EXPORT CString fileSystemRepresentation(const String&);
 
 inline bool isHandleValid(const PlatformFileHandle& handle) { return handle != invalidPlatformFileHandle; }
 
@@ -162,14 +162,14 @@ inline double invalidFileTime() { return std::numeric_limits<double>::quiet_NaN(
 inline bool isValidFileTime(double time) { return std::isfinite(time); }
 
 // Prefix is what the filename should be prefixed with, not the full path.
-String openTemporaryFile(const String& prefix, PlatformFileHandle&);
-PlatformFileHandle openFile(const String& path, FileOpenMode);
-void closeFile(PlatformFileHandle&);
+WEBCORE_EXPORT String openTemporaryFile(const String& prefix, PlatformFileHandle&);
+WEBCORE_EXPORT PlatformFileHandle openFile(const String& path, FileOpenMode);
+WEBCORE_EXPORT void closeFile(PlatformFileHandle&);
 // Returns the resulting offset from the beginning of the file if successful, -1 otherwise.
 long long seekFile(PlatformFileHandle, long long offset, FileSeekOrigin);
 bool truncateFile(PlatformFileHandle, long long offset);
 // Returns number of bytes actually read if successful, -1 otherwise.
-int writeToFile(PlatformFileHandle, const char* data, int length);
+WEBCORE_EXPORT int writeToFile(PlatformFileHandle, const char* data, int length);
 // Returns number of bytes actually written if successful, -1 otherwise.
 int readFromFile(PlatformFileHandle, char* data, int length);
 #if USE(FILE_LOCK)
@@ -181,7 +181,7 @@ bool unlockFile(PlatformFileHandle);
 bool unloadModule(PlatformModule);
 
 // Encode a string for use within a file name.
-String encodeForFileName(const String&);
+WEBCORE_EXPORT String encodeForFileName(const String&);
 
 #if USE(CF)
 RetainPtr<CFURLRef> pathAsURL(const String&);
index bac32f3..3185f86 100644 (file)
 
 namespace WebCore {
 
-String defaultLanguage();
-Vector<String> userPreferredLanguages();
+WEBCORE_EXPORT String defaultLanguage();
+WEBCORE_EXPORT Vector<String> userPreferredLanguages();
 Vector<String> userPreferredLanguagesOverride();
-void overrideUserPreferredLanguages(const Vector<String>&);
+WEBCORE_EXPORT void overrideUserPreferredLanguages(const Vector<String>&);
 size_t indexOfBestMatchingLanguageInList(const String& language, const Vector<String>& languageList);
 
 // The observer function will be called when system language changes.
 typedef void (*LanguageChangeObserverFunction)(void* context);
-void addLanguageChangeObserver(void* context, LanguageChangeObserverFunction);
-void removeLanguageChangeObserver(void* context);
+WEBCORE_EXPORT void addLanguageChangeObserver(void* context, LanguageChangeObserverFunction);
+WEBCORE_EXPORT void removeLanguageChangeObserver(void* context);
 
 Vector<String> platformUserPreferredLanguages();
 
 String displayNameForLanguageLocale(const String&);
 
 // Called from platform specific code when the user's preferred language(s) change.
-void languageDidChange();
+WEBCORE_EXPORT void languageDidChange();
 }
 
 #endif
index 039942f..165995f 100644 (file)
@@ -54,8 +54,8 @@ struct LinkHashHash {
 };
 
 // Returns the hash of the string that will be used for visited link coloring.
-LinkHash visitedLinkHash(const String& url);
-LinkHash visitedLinkHash(const UChar* url, unsigned length);
+WEBCORE_EXPORT LinkHash visitedLinkHash(const String& url);
+WEBCORE_EXPORT LinkHash visitedLinkHash(const UChar* url, unsigned length);
 
 // Resolves the potentially relative URL "attributeURL" relative to the given
 // base URL, and returns the hash of the string that will be used for visited
index d4c5e94..8b153d0 100644 (file)
@@ -198,9 +198,9 @@ namespace WebCore {
 #endif
 
 #if PLATFORM(COCOA)
-    String builtInPDFPluginName();
-    String pdfDocumentTypeDescription();
-    String postScriptDocumentTypeDescription();
+    WEBCORE_EXPORT String builtInPDFPluginName();
+    WEBCORE_EXPORT String pdfDocumentTypeDescription();
+    WEBCORE_EXPORT String postScriptDocumentTypeDescription();
     String keygenMenuItem512();
     String keygenMenuItem1024();
     String keygenMenuItem2048();
@@ -262,7 +262,7 @@ namespace WebCore {
     String snapshottedPlugInLabelTitle();
     String snapshottedPlugInLabelSubtitle();
 
-    String useBlockedPlugInContextMenuTitle();
+    WEBCORE_EXPORT String useBlockedPlugInContextMenuTitle();
 
 #if ENABLE(SUBTLE_CRYPTO)
     String webCryptoMasterKeyKeychainLabel(const String& localizedApplicationName);
@@ -272,7 +272,7 @@ namespace WebCore {
 #define WEB_UI_STRING(string, description) WebCore::localizedString(string)
 #define WEB_UI_STRING_KEY(string, key, description) WebCore::localizedString(key)
 
-    String localizedString(const char* key);
+    WEBCORE_EXPORT String localizedString(const char* key);
 
 } // namespace WebCore
 
index b9c9826..52593a6 100644 (file)
@@ -83,7 +83,7 @@ WEBCORE_LOG_CHANNELS(DECLARE_LOG_CHANNEL)
 
     String logLevelString();
     bool isLogChannelEnabled(const String& name);
-    void initializeLoggingChannelsIfNecessary();
+    WEBCORE_EXPORT void initializeLoggingChannelsIfNecessary();
 }
 
 #endif // !LOG_DISABLED
index 276d95b..00a9a58 100644 (file)
@@ -131,7 +131,7 @@ private:
 };
  
 // Function to obtain the global memory pressure object.
-MemoryPressureHandler& memoryPressureHandler();
+WEBCORE_EXPORT MemoryPressureHandler& memoryPressureHandler();
 
 } // namespace WebCore
 
index 2920fbe..9e69012 100644 (file)
@@ -39,7 +39,7 @@
 #else
 
 namespace WebCore {
-WTFLogChannel* notImplementedLoggingChannel();
+WEBCORE_EXPORT WTFLogChannel* notImplementedLoggingChannel();
 }
 
 #define notImplemented() do { \
index 51962f7..d9164f1 100644 (file)
@@ -122,7 +122,7 @@ private:
 };
 
 PlatformStrategies* platformStrategies();
-void setPlatformStrategies(PlatformStrategies*);
+WEBCORE_EXPORT void setPlatformStrategies(PlatformStrategies*);
 bool hasPlatformStrategies();
     
 } // namespace WebCore
index 80a3d4c..073065f 100644 (file)
@@ -32,7 +32,7 @@
 
 namespace WebCore {
 
-bool isPublicSuffix(const String& domain);
+WEBCORE_EXPORT bool isPublicSuffix(const String& domain);
 String topPrivatelyControlledDomain(const String& domain);
 
 } // namespace WebCore
index 5dd1b6e..6979b2a 100644 (file)
 
 namespace WebCore {
 
-bool applicationIsAOLInstantMessenger();
-bool applicationIsAdobeInstaller();
-bool applicationIsAperture();
-bool applicationIsAppleMail();
+WEBCORE_EXPORT bool applicationIsAOLInstantMessenger();
+WEBCORE_EXPORT bool applicationIsAdobeInstaller();
+WEBCORE_EXPORT bool applicationIsAperture();
+WEBCORE_EXPORT bool applicationIsAppleMail();
 bool applicationIsITunes();
-bool applicationIsMicrosoftMessenger();
-bool applicationIsMicrosoftMyDay();
-bool applicationIsMicrosoftOutlook();
+WEBCORE_EXPORT bool applicationIsMicrosoftMessenger();
+WEBCORE_EXPORT bool applicationIsMicrosoftMyDay();
+WEBCORE_EXPORT bool applicationIsMicrosoftOutlook();
 bool applicationIsQuickenEssentials();
-bool applicationIsSafari();
+WEBCORE_EXPORT bool applicationIsSafari();
 bool applicationIsSolidStateNetworksDownloader();
-bool applicationIsVersions();
-bool applicationIsHRBlock();
+WEBCORE_EXPORT bool applicationIsVersions();
+WEBCORE_EXPORT bool applicationIsHRBlock();
 
 } // namespace WebCore
 
index 0e4c5c3..346c756 100644 (file)
 namespace WebCore {
 
 bool applicationIsAdSheet();
-bool applicationIsMobileMail();
-bool applicationIsMobileSafari();
+WEBCORE_EXPORT bool applicationIsMobileMail();
+WEBCORE_EXPORT bool applicationIsMobileSafari();
 bool applicationIsDumpRenderTree();
 bool applicationIsMobileStore();
-bool applicationIsWebApp();
-bool applicationIsOkCupid();
-bool applicationIsFacebook();
+WEBCORE_EXPORT bool applicationIsWebApp();
+WEBCORE_EXPORT bool applicationIsOkCupid();
+WEBCORE_EXPORT bool applicationIsFacebook();
 bool applicationIsEpicurious();
-bool applicationIsDaijisenDictionary();
+WEBCORE_EXPORT bool applicationIsDaijisenDictionary();
 bool applicationIsNASAHD();
 bool applicationIsMASH();
-bool applicationIsTheEconomistOnIPhone();
+WEBCORE_EXPORT bool applicationIsTheEconomistOnIPhone();
 bool applicationIsWebProcess();
 bool applicationIsIBooksOnIOS();
 
index d2a2cc7..f704637 100644 (file)
@@ -36,30 +36,30 @@ typedef HashSet<String, CaseFoldingHash> URLSchemesMap;
 
 class SchemeRegistry {
 public:
-    static void registerURLSchemeAsLocal(const String&);
+    WEBCORE_EXPORT static void registerURLSchemeAsLocal(const String&);
     static void removeURLSchemeRegisteredAsLocal(const String&);
     static const URLSchemesMap& localSchemes();
 
-    static bool shouldTreatURLSchemeAsLocal(const String&);
+    WEBCORE_EXPORT static bool shouldTreatURLSchemeAsLocal(const String&);
 
     // Secure schemes do not trigger mixed content warnings. For example,
     // https and data are secure schemes because they cannot be corrupted by
     // active network attackers.
-    static void registerURLSchemeAsSecure(const String&);
+    WEBCORE_EXPORT static void registerURLSchemeAsSecure(const String&);
     static bool shouldTreatURLSchemeAsSecure(const String&);
 
-    static void registerURLSchemeAsNoAccess(const String&);
+    WEBCORE_EXPORT static void registerURLSchemeAsNoAccess(const String&);
     static bool shouldTreatURLSchemeAsNoAccess(const String&);
 
     // Display-isolated schemes can only be displayed (in the sense of
     // SecurityOrigin::canDisplay) by documents from the same scheme.
-    static void registerURLSchemeAsDisplayIsolated(const String&);
+    WEBCORE_EXPORT static void registerURLSchemeAsDisplayIsolated(const String&);
     static bool shouldTreatURLSchemeAsDisplayIsolated(const String&);
 
-    static void registerURLSchemeAsEmptyDocument(const String&);
-    static bool shouldLoadURLSchemeAsEmptyDocument(const String&);
+    WEBCORE_EXPORT static void registerURLSchemeAsEmptyDocument(const String&);
+    WEBCORE_EXPORT static bool shouldLoadURLSchemeAsEmptyDocument(const String&);
 
-    static void setDomainRelaxationForbiddenForURLScheme(bool forbidden, const String&);
+    WEBCORE_EXPORT static void setDomainRelaxationForbiddenForURLScheme(bool forbidden, const String&);
     static bool isDomainRelaxationForbiddenForURLScheme(const String&);
 
     // Such schemes should delegate to SecurityOrigin::canRequest for any URL
@@ -74,19 +74,19 @@ public:
 
     // Let some schemes opt-out of Private Browsing's default behavior of prohibiting read/write
     // access to Local Storage and Databases.
-    static void registerURLSchemeAsAllowingLocalStorageAccessInPrivateBrowsing(const String& scheme);
-    static bool allowsLocalStorageAccessInPrivateBrowsing(const String& scheme);
-    static void registerURLSchemeAsAllowingDatabaseAccessInPrivateBrowsing(const String& scheme);
+    WEBCORE_EXPORT static void registerURLSchemeAsAllowingLocalStorageAccessInPrivateBrowsing(const String& scheme);
+    WEBCORE_EXPORT static bool allowsLocalStorageAccessInPrivateBrowsing(const String& scheme);
+    WEBCORE_EXPORT static void registerURLSchemeAsAllowingDatabaseAccessInPrivateBrowsing(const String& scheme);
     static bool allowsDatabaseAccessInPrivateBrowsing(const String& scheme);
 
     // Allow non-HTTP schemes to be registered to allow CORS requests.
-    static void registerURLSchemeAsCORSEnabled(const String& scheme);
+    WEBCORE_EXPORT static void registerURLSchemeAsCORSEnabled(const String& scheme);
     static bool shouldTreatURLSchemeAsCORSEnabled(const String& scheme);
 
     // Allow resources from some schemes to load on a page, regardless of its
     // Content Security Policy.
-    static void registerURLSchemeAsBypassingContentSecurityPolicy(const String& scheme);
-    static void removeURLSchemeRegisteredAsBypassingContentSecurityPolicy(const String& scheme);
+    WEBCORE_EXPORT static void registerURLSchemeAsBypassingContentSecurityPolicy(const String& scheme);
+    WEBCORE_EXPORT static void removeURLSchemeRegisteredAsBypassingContentSecurityPolicy(const String& scheme);
     static bool schemeShouldBypassContentSecurityPolicy(const String& scheme);
     
     // Schemes whose responses can be cached indefinitely.
@@ -94,7 +94,7 @@ public:
 
 #if ENABLE(CACHE_PARTITIONING)
     // Schemes whose requests should be partitioned in the cache
-    static void registerURLSchemeAsCachePartitioned(const String& scheme);
+    WEBCORE_EXPORT static void registerURLSchemeAsCachePartitioned(const String& scheme);
     static bool shouldPartitionCacheForURLScheme(const String& scheme);
 #endif
 };
index eb613cf..998d3e2 100644 (file)
@@ -71,7 +71,7 @@ public:
     // ScrollableArea functions.
     virtual int scrollSize(ScrollbarOrientation) const override;
     virtual int scrollPosition(Scrollbar*) const override;
-    virtual void setScrollOffset(const IntPoint&) override;
+    WEBCORE_EXPORT virtual void setScrollOffset(const IntPoint&) override;
     virtual bool isScrollCornerVisible() const override;
     virtual void scrollbarStyleChanged(int newStyle, bool forceUpdate) override;
 
@@ -89,7 +89,7 @@ public:
 
     // Functions for child manipulation and inspection.
     const HashSet<RefPtr<Widget>>& children() const { return m_children; }
-    virtual void addChild(PassRefPtr<Widget>);
+    WEBCORE_EXPORT virtual void addChild(PassRefPtr<Widget>);
     virtual void removeChild(Widget*);
 
     // If the scroll view does not use a native widget, then it will have cross-platform Scrollbars. These functions
@@ -108,7 +108,7 @@ public:
     void setScrollbarModes(ScrollbarMode horizontalMode, ScrollbarMode verticalMode, bool horizontalLock = false, bool verticalLock = false);
     void setHorizontalScrollbarMode(ScrollbarMode mode, bool lock = false) { setScrollbarModes(mode, verticalScrollbarMode(), lock, verticalScrollbarLock()); }
     void setVerticalScrollbarMode(ScrollbarMode mode, bool lock = false) { setScrollbarModes(horizontalScrollbarMode(), mode, horizontalScrollbarLock(), lock); };
-    void scrollbarModes(ScrollbarMode& horizontalMode, ScrollbarMode& verticalMode) const;
+    WEBCORE_EXPORT void scrollbarModes(ScrollbarMode& horizontalMode, ScrollbarMode& verticalMode) const;
     ScrollbarMode horizontalScrollbarMode() const { ScrollbarMode horizontal, vertical; scrollbarModes(horizontal, vertical); return horizontal; }
     ScrollbarMode verticalScrollbarMode() const { ScrollbarMode horizontal, vertical; scrollbarModes(horizontal, vertical); return vertical; }
 
@@ -119,7 +119,7 @@ public:
 
     void setScrollingModesLock(bool lock = true) { m_horizontalScrollbarLock = m_verticalScrollbarLock = lock; }
 
-    virtual void setCanHaveScrollbars(bool);
+    WEBCORE_EXPORT virtual void setCanHaveScrollbars(bool);
     bool canHaveScrollbars() const { return horizontalScrollbarMode() != ScrollbarAlwaysOff || verticalScrollbarMode() != ScrollbarAlwaysOff; }
 
     virtual bool avoidScrollbarCreation() const { return false; }
@@ -129,7 +129,7 @@ public:
     // By default you only receive paint events for the area that is visible. In the case of using a
     // tiled backing store, this function can be set, so that the view paints the entire contents.
     bool paintsEntireContents() const { return m_paintsEntireContents; }
-    void setPaintsEntireContents(bool);
+    WEBCORE_EXPORT void setPaintsEntireContents(bool);
 
     // By default, paint events are clipped to the visible area.  If set to
     // false, paint events are no longer clipped.  paintsEntireContents() implies !clipsRepaints().
@@ -140,7 +140,7 @@ public:
     // In the case of using a tiled backing store, this mode can be set, so that the scroll requests
     // are delegated to the UI application.
     bool delegatesScrolling() const { return m_delegatesScrolling; }
-    void setDelegatesScrolling(bool);
+    WEBCORE_EXPORT void setDelegatesScrolling(bool);
 
     // Overridden by FrameView to create custom CSS scrollbars if applicable.
     virtual PassRefPtr<Scrollbar> createScrollbar(ScrollbarOrientation);
@@ -189,12 +189,12 @@ public:
 
 #if PLATFORM(IOS)
     // This is the area that is partially or fully exposed, and may extend under overlapping UI elements.
-    FloatRect exposedContentRect() const;
+    WEBCORE_EXPORT FloatRect exposedContentRect() const;
 
     // The given rects are only used if there is no platform widget.
-    void setExposedContentRect(const FloatRect&);
+    WEBCORE_EXPORT void setExposedContentRect(const FloatRect&);
     const FloatSize& unobscuredContentSize() const { return m_unobscuredContentSize; }
-    void setUnobscuredContentSize(const FloatSize&);
+    WEBCORE_EXPORT void setUnobscuredContentSize(const FloatSize&);
 
     void setActualScrollPosition(const IntPoint&);
     LegacyTileCache* legacyTileCache();
@@ -216,14 +216,14 @@ public:
     IntSize layoutSize() const;
     int layoutWidth() const { return layoutSize().width(); }
     int layoutHeight() const { return layoutSize().height(); }
-    IntSize fixedLayoutSize() const;
-    void setFixedLayoutSize(const IntSize&);
-    bool useFixedLayout() const;
-    void setUseFixedLayout(bool enable);
+    WEBCORE_EXPORT IntSize fixedLayoutSize() const;
+    WEBCORE_EXPORT void setFixedLayoutSize(const IntSize&);
+    WEBCORE_EXPORT bool useFixedLayout() const;
+    WEBCORE_EXPORT void setUseFixedLayout(bool enable);
 
     // Functions for getting/setting the size of the document contained inside the ScrollView (as an IntSize or as individual width and height
     // values).
-    virtual IntSize contentsSize() const override; // Always at least as big as the visibleWidth()/visibleHeight().
+    WEBCORE_EXPORT virtual IntSize contentsSize() const override; // Always at least as big as the visibleWidth()/visibleHeight().
     int contentsWidth() const { return contentsSize().width(); }
     int contentsHeight() const { return contentsSize().height(); }
     virtual void setContentsSize(const IntSize&);
@@ -262,7 +262,7 @@ public:
     // top of the document anyway, since there could also be header. documentScrollOffsetRelativeToViewOrigin()
     // will return a version of the current scroll offset which tracks the top of the Document
     // relative to the very top of the view.
-    IntSize documentScrollOffsetRelativeToViewOrigin() const;
+    WEBCORE_EXPORT IntSize documentScrollOffsetRelativeToViewOrigin() const;
     IntPoint documentScrollPositionRelativeToViewOrigin() const;
 
     virtual IntSize overhangAmount() const override;
@@ -284,26 +284,26 @@ public:
     void scrollContents(const IntSize& scrollDelta);
 
     // This gives us a means of blocking painting on our scrollbars until the first layout has occurred.
-    void setScrollbarsSuppressed(bool suppressed, bool repaintOnUnsuppress = false);
+    WEBCORE_EXPORT void setScrollbarsSuppressed(bool suppressed, bool repaintOnUnsuppress = false);
     bool scrollbarsSuppressed() const { return m_scrollbarsSuppressed; }
 
-    IntPoint rootViewToContents(const IntPoint&) const;
-    IntPoint contentsToRootView(const IntPoint&) const;
+    WEBCORE_EXPORT IntPoint rootViewToContents(const IntPoint&) const;
+    WEBCORE_EXPORT IntPoint contentsToRootView(const IntPoint&) const;
     IntRect rootViewToContents(const IntRect&) const;
-    IntRect contentsToRootView(const IntRect&) const;
+    WEBCORE_EXPORT IntRect contentsToRootView(const IntRect&) const;
 
-    IntPoint rootViewToTotalContents(const IntPoint&) const;
+    WEBCORE_EXPORT IntPoint rootViewToTotalContents(const IntPoint&) const;
 
     // Event coordinates are assumed to be in the coordinate space of a window that contains
     // the entire widget hierarchy. It is up to the platform to decide what the precise definition
     // of containing window is. (For example on Mac it is the containing NSWindow.)
-    IntPoint windowToContents(const IntPoint&) const;
-    IntPoint contentsToWindow(const IntPoint&) const;
-    IntRect windowToContents(const IntRect&) const;
-    IntRect contentsToWindow(const IntRect&) const;
+    WEBCORE_EXPORT IntPoint windowToContents(const IntPoint&) const;
+    WEBCORE_EXPORT IntPoint contentsToWindow(const IntPoint&) const;
+    WEBCORE_EXPORT IntRect windowToContents(const IntRect&) const;
+    WEBCORE_EXPORT IntRect contentsToWindow(const IntRect&) const;
 
     // Functions for converting to and from screen coordinates.
-    IntRect contentsToScreen(const IntRect&) const;
+    WEBCORE_EXPORT IntRect contentsToScreen(const IntRect&) const;
     IntPoint screenToContents(const IntPoint&) const;
 
     // The purpose of this function is to answer whether or not the scroll view is currently visible. Animations and painting updates can be suspended if
@@ -315,7 +315,7 @@ public:
     virtual IntRect windowResizerRect() const { return IntRect(); }
     bool containsScrollbarsAvoidingResizer() const;
     void adjustScrollbarsAvoidingResizerCount(int overlapDelta);
-    void windowResizerRectChanged();
+    WEBCORE_EXPORT void windowResizerRectChanged();
 
     virtual void setParent(ScrollView*) override; // Overridden to update the overlapping scrollbar count.
 
@@ -350,13 +350,13 @@ public:
     }
 
     // Widget override. Handles painting of the contents of the view as well as the scrollbars.
-    virtual void paint(GraphicsContext*, const IntRect&) override;
+    WEBCORE_EXPORT virtual void paint(GraphicsContext*, const IntRect&) override;
     void paintScrollbars(GraphicsContext*, const IntRect&);
 
     // Widget overrides to ensure that our children's visibility status is kept up to date when we get shown and hidden.
-    virtual void show() override;
-    virtual void hide() override;
-    virtual void setParentVisible(bool) override;
+    WEBCORE_EXPORT virtual void show() override;
+    WEBCORE_EXPORT virtual void hide() override;
+    WEBCORE_EXPORT virtual void setParentVisible(bool) override;
     
     // Pan scrolling.
     static const int noPanScrollRadius = 15;
@@ -419,7 +419,7 @@ protected:
 
 private:
     virtual IntRect visibleContentRectInternal(VisibleContentRectIncludesScrollbars, VisibleContentRectBehavior) const override;
-    IntRect unobscuredContentRectInternal(VisibleContentRectIncludesScrollbars = ExcludeScrollbars) const;
+    WEBCORE_EXPORT IntRect unobscuredContentRectInternal(VisibleContentRectIncludesScrollbars = ExcludeScrollbars) const;
 
     RefPtr<Scrollbar> m_horizontalScrollbar;
     RefPtr<Scrollbar> m_verticalScrollbar;
@@ -500,7 +500,7 @@ private:
 
 #if PLATFORM(COCOA) && defined __OBJC__
 public:
-    NSView* documentView() const;
+    WEBCORE_EXPORT NSView* documentView() const;
 
 private:
     NSScrollView<WebCoreFrameScrollView>* scrollView() const;
index 3e9c03e..443cd54 100644 (file)
@@ -43,20 +43,20 @@ class TiledBacking;
 
 class ScrollableArea {
 public:
-    bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1);
-    void scrollToOffsetWithoutAnimation(const FloatPoint&);
+    WEBCORE_EXPORT bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1);
+    WEBCORE_EXPORT void scrollToOffsetWithoutAnimation(const FloatPoint&);
     void scrollToOffsetWithoutAnimation(ScrollbarOrientation, float offset);
 
     // Should be called when the scroll position changes externally, for example if the scroll layer position
     // is updated on the scrolling thread and we need to notify the main thread.
-    void notifyScrollPositionChanged(const IntPoint&);
+    WEBCORE_EXPORT void notifyScrollPositionChanged(const IntPoint&);
 
     // Allows subclasses to handle scroll position updates themselves. If this member function
     // returns true, the scrollable area won't actually update the scroll position and instead
     // expect it to happen sometime in the future.
     virtual bool requestScrollPositionUpdate(const IntPoint&) { return false; }
 
-    bool handleWheelEvent(const PlatformWheelEvent&);
+    WEBCORE_EXPORT bool handleWheelEvent(const PlatformWheelEvent&);
 
 #if ENABLE(CSS_SCROLL_SNAP)
     const Vector<LayoutUnit>* horizontalSnapOffsets() const { return m_horizontalSnapOffsets.get(); };
@@ -92,32 +92,32 @@ public:
     ScrollElasticity horizontalScrollElasticity() const { return static_cast<ScrollElasticity>(m_horizontalScrollElasticity); }
 
     bool inLiveResize() const { return m_inLiveResize; }
-    virtual void willStartLiveResize();
-    virtual void willEndLiveResize();
-
-    void contentAreaWillPaint() const;
-    void mouseEnteredContentArea() const;
-    void mouseExitedContentArea() const;
-    void mouseMovedInContentArea() const;
-    void mouseEnteredScrollbar(Scrollbar*) const;
+    WEBCORE_EXPORT virtual void willStartLiveResize();
+    WEBCORE_EXPORT virtual void willEndLiveResize();
+
+    WEBCORE_EXPORT void contentAreaWillPaint() const;
+    WEBCORE_EXPORT void mouseEnteredContentArea() const;
+    WEBCORE_EXPORT void mouseExitedContentArea() const;
+    WEBCORE_EXPORT void mouseMovedInContentArea() const;
+    WEBCORE_EXPORT void mouseEnteredScrollbar(Scrollbar*) const;
     void mouseExitedScrollbar(Scrollbar*) const;
     void contentAreaDidShow() const;
     void contentAreaDidHide() const;
 
     void lockOverlayScrollbarStateToHidden(bool shouldLockState) const;
-    bool scrollbarsCanBeActive() const;
+    WEBCORE_EXPORT bool scrollbarsCanBeActive() const;
 
-    virtual void didAddScrollbar(Scrollbar*, ScrollbarOrientation);
-    virtual void willRemoveScrollbar(Scrollbar*, ScrollbarOrientation);
+    WEBCORE_EXPORT virtual void didAddScrollbar(Scrollbar*, ScrollbarOrientation);
+    WEBCORE_EXPORT virtual void willRemoveScrollbar(Scrollbar*, ScrollbarOrientation);
 
-    virtual void contentsResized();
+    WEBCORE_EXPORT virtual void contentsResized();
 
     bool hasOverlayScrollbars() const;
-    virtual void setScrollbarOverlayStyle(ScrollbarOverlayStyle);
+    WEBCORE_EXPORT virtual void setScrollbarOverlayStyle(ScrollbarOverlayStyle);
     ScrollbarOverlayStyle scrollbarOverlayStyle() const { return static_cast<ScrollbarOverlayStyle>(m_scrollbarOverlayStyle); }
 
     // This getter will create a ScrollAnimator if it doesn't already exist.
-    ScrollAnimator* scrollAnimator() const;
+    WEBCORE_EXPORT ScrollAnimator* scrollAnimator() const;
 
     // This getter will return null if the ScrollAnimator hasn't been created yet.
     ScrollAnimator* existingScrollAnimator() const { return m_scrollAnimator.get(); }
@@ -128,10 +128,10 @@ public:
     virtual bool isActive() const = 0;
     virtual int scrollSize(ScrollbarOrientation) const = 0;
     virtual int scrollPosition(Scrollbar*) const = 0;
-    virtual void invalidateScrollbar(Scrollbar*, const IntRect&);
+    WEBCORE_EXPORT virtual void invalidateScrollbar(Scrollbar*, const IntRect&);
     virtual bool isScrollCornerVisible() const = 0;
     virtual IntRect scrollCornerRect() const = 0;
-    virtual void invalidateScrollCorner(const IntRect&);
+    WEBCORE_EXPORT virtual void invalidateScrollCorner(const IntRect&);
 
     virtual bool updatesScrollLayerPositionOnMainThread() const = 0;
 
@@ -163,10 +163,10 @@ public:
     virtual IntPoint scrollPosition() const;
     virtual IntPoint minimumScrollPosition() const;
     virtual IntPoint maximumScrollPosition() const;
-    virtual bool scrolledToTop() const;
-    virtual bool scrolledToBottom() const;
-    virtual bool scrolledToLeft() const;
-    virtual bool scrolledToRight() const;
+    WEBCORE_EXPORT virtual bool scrolledToTop() const;
+    WEBCORE_EXPORT virtual bool scrolledToBottom() const;
+    WEBCORE_EXPORT virtual bool scrolledToLeft() const;
+    WEBCORE_EXPORT virtual bool scrolledToRight() const;
 
     bool isScrolledProgrammatically() const { return m_scrolledProgrammatically; }
     void setScrolledProgrammatically(bool state) { m_scrolledProgrammatically = state; }
@@ -182,8 +182,8 @@ public:
 #endif
     };
 
-    IntRect visibleContentRect(VisibleContentRectBehavior = ContentsVisibleRect) const;
-    IntRect visibleContentRectIncludingScrollbars(VisibleContentRectBehavior = ContentsVisibleRect) const;
+    WEBCORE_EXPORT IntRect visibleContentRect(VisibleContentRectBehavior = ContentsVisibleRect) const;
+    WEBCORE_EXPORT IntRect visibleContentRectIncludingScrollbars(VisibleContentRectBehavior = ContentsVisibleRect) const;
 
     int visibleWidth() const { return visibleSize().width(); }
     int visibleHeight() const { return visibleSize().height(); }
@@ -198,7 +198,7 @@ public:
     virtual int footerHeight() const { return 0; }
 
     // The totalContentsSize() is equivalent to the contentsSize() plus the header and footer heights.
-    IntSize totalContentsSize() const;
+    WEBCORE_EXPORT IntSize totalContentsSize() const;
 
     virtual bool shouldSuspendScrollAnimations() const { return true; }
     virtual void scrollbarStyleChanged(int /*newStyle*/, bool /*forceUpdate*/) { }
@@ -215,9 +215,9 @@ public:
     virtual bool scrollAnimatorEnabled() const { return false; }
 
     // NOTE: Only called from Internals for testing.
-    void setScrollOffsetFromInternals(const IntPoint&);
+    WEBCORE_EXPORT void setScrollOffsetFromInternals(const IntPoint&);
 
-    static LayoutPoint constrainScrollPositionForOverhang(const LayoutRect& visibleContentRect, const LayoutSize& totalContentsSize, const LayoutPoint& scrollPosition, const LayoutPoint& scrollOrigin, int headerHeight, int footetHeight);
+    WEBCORE_EXPORT static LayoutPoint constrainScrollPositionForOverhang(const LayoutRect& visibleContentRect, const LayoutSize& totalContentsSize, const LayoutPoint& scrollPosition, const LayoutPoint& scrollOrigin, int headerHeight, int footetHeight);
     LayoutPoint constrainScrollPositionForOverhang(const LayoutPoint& scrollPosition);
 
     // Computes the double value for the scrollbar's current position and the current overhang amount.
@@ -253,8 +253,8 @@ public:
     void horizontalScrollbarLayerDidChange();
 
 protected:
-    ScrollableArea();
-    virtual ~ScrollableArea();
+    WEBCORE_EXPORT ScrollableArea();
+    WEBCORE_EXPORT virtual ~ScrollableArea();
 
     void setScrollOrigin(const IntPoint&);
     void resetScrollOriginChanged() { m_scrollOriginChanged = false; }
@@ -272,7 +272,7 @@ protected:
     bool hasLayerForScrollCorner() const;
 
 private:
-    virtual IntRect visibleContentRectInternal(VisibleContentRectIncludesScrollbars, VisibleContentRectBehavior) const;
+    WEBCORE_EXPORT virtual IntRect visibleContentRectInternal(VisibleContentRectIncludesScrollbars, VisibleContentRectBehavior) const;
     void scrollPositionChanged(const IntPoint&);
     
     // NOTE: Only called from the ScrollAnimator.
index cda8174..3b76736 100644 (file)
@@ -45,7 +45,7 @@ class Scrollbar : public Widget,
 
 public:
     // Must be implemented by platforms that can't simply use the Scrollbar base class.  Right now the only platform that is not using the base class is GTK.
-    static PassRefPtr<Scrollbar> createNativeScrollbar(ScrollableArea*, ScrollbarOrientation orientation, ScrollbarControlSize size);
+    WEBCORE_EXPORT static PassRefPtr<Scrollbar> createNativeScrollbar(ScrollableArea*, ScrollbarOrientation orientation, ScrollbarControlSize size);
 
     virtual ~Scrollbar();
 
@@ -98,7 +98,7 @@ public:
 
     static int pixelsPerLineStep() { return 40; }
     static float minFractionToStepWhenPaging() { return 0.875f; }
-    static int maxOverlapBetweenPages();
+    WEBCORE_EXPORT static int maxOverlapBetweenPages();
     static int pageStep(int widthOrHeight) { return std::max(std::max<int>(lroundf(widthOrHeight * Scrollbar::minFractionToStepWhenPaging()), lroundf(widthOrHeight - Scrollbar::maxOverlapBetweenPages())), 1); }
     static float pageStepDelta(int widthOrHeight) { return std::max(std::max(static_cast<float>(widthOrHeight) * Scrollbar::minFractionToStepWhenPaging(), static_cast<float>(widthOrHeight) - Scrollbar::maxOverlapBetweenPages()), 1.0f); }
 
@@ -112,8 +112,8 @@ public:
     virtual void setHoveredPart(ScrollbarPart);
     virtual void setPressedPart(ScrollbarPart);
 
-    void setSteps(int lineStep, int pageStep, int pixelsPerStep = 1);
-    void setProportion(int visibleSize, int totalSize);
+    WEBCORE_EXPORT void setSteps(int lineStep, int pageStep, int pixelsPerStep = 1);
+    WEBCORE_EXPORT void setProportion(int visibleSize, int totalSize);
     void setPressedPos(int p) { m_pressedPos = p; }
 
     virtual void paint(GraphicsContext*, const IntRect& damageRect) override;
@@ -127,15 +127,15 @@ public:
     // when the mouse went down in a scrollbar, since it is assumed the scrollbar will start
     // grabbing all events in that case anyway.
 #if !PLATFORM(IOS)
-    bool mouseMoved(const PlatformMouseEvent&);
+    WEBCORE_EXPORT bool mouseMoved(const PlatformMouseEvent&);
 #endif
-    void mouseEntered();
-    bool mouseExited();
+    WEBCORE_EXPORT void mouseEntered();
+    WEBCORE_EXPORT bool mouseExited();
 
     // Used by some platform scrollbars to know when they've been released from capture.
-    bool mouseUp(const PlatformMouseEvent&);
+    WEBCORE_EXPORT bool mouseUp(const PlatformMouseEvent&);
 
-    bool mouseDown(const PlatformMouseEvent&);
+    WEBCORE_EXPORT bool mouseDown(const PlatformMouseEvent&);
 
     ScrollbarTheme* theme() const { return m_theme; }
 
index 5898bd8..93a7d77 100644 (file)
@@ -113,7 +113,7 @@ public:
 
     virtual bool isMockTheme() const { return false; }
 
-    static ScrollbarTheme* theme();
+    WEBCORE_EXPORT static ScrollbarTheme* theme();
 
 private:
     static ScrollbarTheme* nativeTheme(); // Must be implemented to return the correct theme subclass.
index a7922a8..859d4b5 100644 (file)
@@ -56,20 +56,20 @@ public:
     static PassRefPtr<SharedBuffer> create(const char* c, unsigned i) { return adoptRef(new SharedBuffer(c, i)); }
     static PassRefPtr<SharedBuffer> create(const unsigned char* c, unsigned i) { return adoptRef(new SharedBuffer(c, i)); }
 
-    static PassRefPtr<SharedBuffer> createWithContentsOfFile(const String& filePath);
+    WEBCORE_EXPORT static PassRefPtr<SharedBuffer> createWithContentsOfFile(const String& filePath);
 
-    static PassRefPtr<SharedBuffer> adoptVector(Vector<char>& vector);
+    WEBCORE_EXPORT static PassRefPtr<SharedBuffer> adoptVector(Vector<char>& vector);
     
-    ~SharedBuffer();
+    WEBCORE_EXPORT ~SharedBuffer();
     
 #if USE(FOUNDATION)
-    RetainPtr<NSData> createNSData();
-    static PassRefPtr<SharedBuffer> wrapNSData(NSData *data);
+    WEBCORE_EXPORT RetainPtr<NSData> createNSData();
+    WEBCORE_EXPORT static PassRefPtr<SharedBuffer> wrapNSData(NSData *data);
 #endif
 #if USE(CF)
-    RetainPtr<CFDataRef> createCFData();
-    CFDataRef existingCFData();
-    static PassRefPtr<SharedBuffer> wrapCFData(CFDataRef);
+    WEBCORE_EXPORT RetainPtr<CFDataRef> createCFData();
+    WEBCORE_EXPORT CFDataRef existingCFData();
+    WEBCORE_EXPORT static PassRefPtr<SharedBuffer> wrapCFData(CFDataRef);
 #endif
 
 #if USE(SOUP)
@@ -79,18 +79,18 @@ public:
     // Calling this function will force internal segmented buffers
     // to be merged into a flat buffer. Use getSomeData() whenever possible
     // for better performance.
-    const char* data() const;
+    WEBCORE_EXPORT const char* data() const;
     // Creates an ArrayBuffer and copies this SharedBuffer's contents to that
     // ArrayBuffer without merging segmented buffers into a flat buffer.
     PassRefPtr<ArrayBuffer> createArrayBuffer() const;
 
-    unsigned size() const;
+    WEBCORE_EXPORT unsigned size() const;
 
 
     bool isEmpty() const { return !size(); }
 
-    void append(SharedBuffer*);
-    void append(const char*, unsigned);
+    WEBCORE_EXPORT void append(SharedBuffer*);
+    WEBCORE_EXPORT void append(const char*, unsigned);
     void append(const Vector<char>&);
 
     void clear();
@@ -116,14 +116,14 @@ public:
     //          // Use the data. for example: decoder->decode(segment, length);
     //          pos += length;
     //      }
-    unsigned getSomeData(const char*& data, unsigned position = 0) const;
+    WEBCORE_EXPORT unsigned getSomeData(const char*& data, unsigned position = 0) const;
 
 #if ENABLE(DISK_IMAGE_CACHE)
     enum MemoryMappingState { QueuedForMapping, PreviouslyQueuedForMapping, SuccessAlreadyMapped, FailureCacheFull };
 
     // Calling this will cause this buffer to be memory mapped.
-    MemoryMappingState allowToBeMemoryMapped();
-    bool isAllowedToBeMemoryMapped() const;
+    WEBCORE_EXPORT MemoryMappingState allowToBeMemoryMapped();
+    WEBCORE_EXPORT bool isAllowedToBeMemoryMapped() const;
 
     // This is called to indicate that the memory mapping failed.
     void failedMemoryMap();
@@ -137,23 +137,23 @@ public:
     typedef void* MemoryMappedNotifyCallbackData;
     typedef void (*MemoryMappedNotifyCallback)(PassRefPtr<SharedBuffer>, CompletionStatus, MemoryMappedNotifyCallbackData);
 
-    MemoryMappedNotifyCallbackData memoryMappedNotificationCallbackData() const;
-    MemoryMappedNotifyCallback memoryMappedNotificationCallback() const;
-    void setMemoryMappedNotificationCallback(MemoryMappedNotifyCallback, MemoryMappedNotifyCallbackData);
+    WEBCORE_EXPORT MemoryMappedNotifyCallbackData memoryMappedNotificationCallbackData() const;
+    WEBCORE_EXPORT MemoryMappedNotifyCallback memoryMappedNotificationCallback() const;
+    WEBCORE_EXPORT void setMemoryMappedNotificationCallback(MemoryMappedNotifyCallback, MemoryMappedNotifyCallbackData);
 #endif
 
     void tryReplaceContentsWithPlatformBuffer(SharedBuffer*);
-    bool hasPlatformData() const;
+    WEBCORE_EXPORT bool hasPlatformData() const;
 
     struct DataBuffer : public ThreadSafeRefCounted<DataBuffer> {
         Vector<char> data;
     };
 
 private:
-    SharedBuffer();
+    WEBCORE_EXPORT SharedBuffer();
     explicit SharedBuffer(unsigned);
-    SharedBuffer(const char*, unsigned);
-    SharedBuffer(const unsigned char*, unsigned);
+    WEBCORE_EXPORT SharedBuffer(const char*, unsigned);
+    WEBCORE_EXPORT SharedBuffer(const unsigned char*, unsigned);
     
     // Calling this function will force internal segmented buffers
     // to be merged into a flat buffer. Use getSomeData() whenever possible
index 054603b..a265a97 100644 (file)
@@ -39,8 +39,8 @@ namespace WebCore {
         ThreadViolationRoundTwo,
         MaximumThreadViolationRound
     };
-    void setDefaultThreadViolationBehavior(ThreadViolationBehavior, ThreadViolationRound);
-    void reportThreadViolation(const char* function, ThreadViolationRound);
+    WEBCORE_EXPORT void setDefaultThreadViolationBehavior(ThreadViolationBehavior, ThreadViolationRound);
+    WEBCORE_EXPORT void reportThreadViolation(const char* function, ThreadViolationRound);
 }
 
 extern "C" void WebCoreReportThreadViolation(const char* function, WebCore::ThreadViolationRound);
index 3bc06c3..8f0b141 100644 (file)
@@ -50,8 +50,8 @@ namespace WebCore {
     class ThreadGlobalData {
         WTF_MAKE_NONCOPYABLE(ThreadGlobalData);
     public:
-        ThreadGlobalData();
-        ~ThreadGlobalData();
+        WEBCORE_EXPORT ThreadGlobalData();
+        WEBCORE_EXPORT ~ThreadGlobalData();
         void destroy(); // called on workers to clean up the ThreadGlobalData before the thread exits.
 
         const CachedResourceRequestInitiators& cachedResourceRequestInitiators() { return *m_cachedResourceRequestInitiators; }
@@ -90,17 +90,17 @@ namespace WebCore {
         OwnPtr<TECConverterWrapper> m_cachedConverterTEC;
 #endif
 
-        static ThreadSpecific<ThreadGlobalData>* staticData;
+        WEBCORE_EXPORT static ThreadSpecific<ThreadGlobalData>* staticData;
 #if USE(WEB_THREAD)
-        static ThreadGlobalData* sharedMainThreadStaticData;
+        WEBCORE_EXPORT static ThreadGlobalData* sharedMainThreadStaticData;
 #endif
         friend ThreadGlobalData& threadGlobalData();
     };
 
 #if USE(WEB_THREAD)
-ThreadGlobalData& threadGlobalData();
+WEBCORE_EXPORT ThreadGlobalData& threadGlobalData();
 #else
-ThreadGlobalData& threadGlobalData() PURE_FUNCTION;
+WEBCORE_EXPORT ThreadGlobalData& threadGlobalData() PURE_FUNCTION;
 #endif
     
 } // namespace WebCore
index 843d676..863158d 100644 (file)
@@ -46,17 +46,17 @@ class TimerBase {
     WTF_MAKE_NONCOPYABLE(TimerBase);
     WTF_MAKE_FAST_ALLOCATED;
 public:
-    TimerBase();
-    virtual ~TimerBase();
+    WEBCORE_EXPORT TimerBase();
+    WEBCORE_EXPORT virtual ~TimerBase();
 
-    void start(double nextFireInterval, double repeatInterval);
+    WEBCORE_EXPORT void start(double nextFireInterval, double repeatInterval);
 
     void startRepeating(double repeatInterval) { start(repeatInterval, repeatInterval); }
     void startRepeating(std::chrono::milliseconds repeatInterval) { startRepeating(repeatInterval.count() * 0.001); }
     void startOneShot(double interval) { start(interval, 0); }
     void startOneShot(std::chrono::milliseconds interval) { startOneShot(interval.count() * 0.001); }
 
-    void stop();
+    WEBCORE_EXPORT void stop();
     bool isActive() const;
 
     double nextFireInterval() const;
index 78c9564..d1f0b88 100644 (file)
@@ -58,7 +58,7 @@ public:
     // The argument is an absolute URL string. The string is assumed to be output of URL::string() called on a valid
     // URL object, or indiscernible from such.
     // It is usually best to avoid repeatedly parsing a string, unless memory saving outweigh the possible slow-downs.
-    URL(ParsedURLStringTag, const String&);
+    WEBCORE_EXPORT URL(ParsedURLStringTag, const String&);
     explicit URL(WTF::HashTableDeletedValueType) : m_string(WTF::HashTableDeletedValue) { }
     bool isHashTableDeletedValue() const { return string().isHashTableDeletedValue(); }
 
@@ -69,7 +69,7 @@ public:
     // FIXME: If the base URL is invalid, this always creates an invalid
     // URL. Instead I think it would be better to treat all invalid base URLs
     // the same way we treate null and empty base URLs.
-    URL(const URL& base, const String& relative);
+    WEBCORE_EXPORT URL(const URL& base, const String& relative);
     URL(const URL& base, const String& relative, const TextEncoding&);
 
     static URL fakeURLWithRelativePart(const String&);
@@ -100,31 +100,31 @@ public:
 
     String stringCenterEllipsizedToLength(unsigned length = 1024) const;
 
-    String protocol() const;
-    String host() const;
-    unsigned short port() const;
+    WEBCORE_EXPORT String protocol() const;
+    WEBCORE_EXPORT String host() const;
+    WEBCORE_EXPORT unsigned short port() const;
     bool hasPort() const;
-    String user() const;
-    String pass() const;
-    String path() const;
-    String lastPathComponent() const;
-    String query() const;
-    String fragmentIdentifier() const;
-    bool hasFragmentIdentifier() const;
+    WEBCORE_EXPORT String user() const;
+    WEBCORE_EXPORT String pass() const;
+    WEBCORE_EXPORT String path() const;
+    WEBCORE_EXPORT String lastPathComponent() const;
+    WEBCORE_EXPORT String query() const;
+    WEBCORE_EXPORT String fragmentIdentifier() const;
+    WEBCORE_EXPORT bool hasFragmentIdentifier() const;
 
-    String baseAsString() const;
+    WEBCORE_EXPORT String baseAsString() const;
 
-    String fileSystemPath() const;
+    WEBCORE_EXPORT String fileSystemPath() const;
 
     // Returns true if the current URL's protocol is the same as the null-
     // terminated ASCII argument. The argument must be lower-case.
-    bool protocolIs(const char*) const;
+    WEBCORE_EXPORT bool protocolIs(const char*) const;
     bool protocolIsData() const { return protocolIs("data"); }
     bool protocolIsInHTTPFamily() const;
-    bool isLocalFile() const;
+    WEBCORE_EXPORT bool isLocalFile() const;
     bool isBlankURL() const;
 
-    bool setProtocol(const String&);
+    WEBCORE_EXPORT bool setProtocol(const String&);
     void setHost(const String&);
 
     void removePort();
@@ -138,7 +138,7 @@ public:
 
     // If you pass an empty path for HTTP or HTTPS URLs, the resulting path
     // will be "/".
-    void setPath(const String&);
+    WEBCORE_EXPORT void setPath(const String&);
 
     // The query may begin with a question mark, or, if not, one will be added
     // for you. Setting the query to the empty string will leave a "?" in the
@@ -162,8 +162,8 @@ public:
     operator const String&() const { return string(); }
 
 #if USE(CF)
-    URL(CFURLRef);
-    RetainPtr<CFURLRef> createCFURL() const;
+    WEBCORE_EXPORT URL(CFURLRef);
+    WEBCORE_EXPORT RetainPtr<CFURLRef> createCFURL() const;
 #endif
 
 #if USE(SOUP)
@@ -172,8 +172,8 @@ public:
 #endif
 
 #if USE(FOUNDATION)
-    URL(NSURL*);
-    operator NSURL*() const;
+    WEBCORE_EXPORT URL(NSURL*);
+    WEBCORE_EXPORT operator NSURL*() const;
 #endif
 #ifdef __OBJC__
     operator NSString*() const { return string(); }
@@ -188,7 +188,7 @@ public:
     bool isSafeToSendToAnotherThread() const;
 
 private:
-    void invalidate();
+    WEBCORE_EXPORT void invalidate();
     static bool protocolIs(const String&, const char*);
     void init(const URL&, const String&, const TextEncoding&);
     void copyToBuffer(Vector<char, 512>& buffer) const;
@@ -224,10 +224,10 @@ bool operator!=(const URL&, const URL&);
 bool operator!=(const URL&, const String&);
 bool operator!=(const String&, const URL&);
 
-bool equalIgnoringFragmentIdentifier(const URL&, const URL&);
-bool protocolHostAndPortAreEqual(const URL&, const URL&);
+WEBCORE_EXPORT bool equalIgnoringFragmentIdentifier(const URL&, const URL&);
+WEBCORE_EXPORT bool protocolHostAndPortAreEqual(const URL&, const URL&);
 
-const URL& blankURL();
+WEBCORE_EXPORT const URL& blankURL();
 
 // Functions to do URL operations on strings.
 // These are operations that aren't faster on a parsed URL.
@@ -235,7 +235,7 @@ const URL& blankURL();
 // This is especially important because valid javascript URLs are not necessarily considered valid by URL.
 
 bool protocolIs(const String& url, const char* protocol);
-bool protocolIsJavaScript(const String& url);
+WEBCORE_EXPORT bool protocolIsJavaScript(const String& url);
 bool protocolIsInHTTPFamily(const String& url);
 
 bool isDefaultPortForProtocol(unsigned short port, const String& protocol);
@@ -244,15 +244,15 @@ bool portAllowed(const URL&); // Blacklist ports that should never be used for W
 bool isValidProtocol(const String&);
 
 String mimeTypeFromDataURL(const String& url);
-String mimeTypeFromURL(const URL&);
+WEBCORE_EXPORT String mimeTypeFromURL(const URL&);
 
 // Unescapes the given string using URL escaping rules, given an optional
 // encoding (defaulting to UTF-8 otherwise). DANGER: If the URL has "%00"
 // in it, the resulting string will have embedded null characters!
-String decodeURLEscapeSequences(const String&);
+WEBCORE_EXPORT String decodeURLEscapeSequences(const String&);
 String decodeURLEscapeSequences(const String&, const TextEncoding&);
 
-String encodeWithURLEscapeSequences(const String&);
+WEBCORE_EXPORT String encodeWithURLEscapeSequences(const String&);
 
 // Inlines.
 
@@ -345,7 +345,7 @@ inline unsigned URL::pathAfterLastSlash() const
 }
 
 #if PLATFORM(IOS)
-void enableURLSchemeCanonicalization(bool);
+WEBCORE_EXPORT void enableURLSchemeCanonicalization(bool);
 #endif
 
 } // namespace WebCore
index 6d914dc..3bc9962 100644 (file)
@@ -47,7 +47,7 @@ namespace WebCore {
 // On Windows, version 4 UUIDs are used since Windows 2000 (http://msdn.microsoft.com/en-us/library/aa446557.aspx).
 // On MacOSX, version 4 UUIDs are used since Tiger (http://developer.apple.com/mac/library/technotes/tn/tn1103.html#TNTAG8).
 // On Linux, the kernel offers the procfs pseudo-file /proc/sys/kernel/random/uuid that yields version 4 UUIDs (http://hbfs.wordpress.com/2008/09/30/ueid-unique-enough-ids/).
-String createCanonicalUUIDString();
+WEBCORE_EXPORT String createCanonicalUUIDString();
 
 }
 
index ed2d9b1..0b35fe8 100644 (file)
@@ -55,12 +55,12 @@ public:
 #endif
     };
 
-    explicit UserActivity(const char* description);
+    WEBCORE_EXPORT explicit UserActivity(const char* description);
 
 private:
     friend class HysteresisActivity<UserActivity>;
 
-    void started();
+    WEBCORE_EXPORT void started();
     void stopped();
 
     Impl m_impl;
index 699d771..0ff11d2 100644 (file)
@@ -93,11 +93,11 @@ enum WidgetNotification { WillPaintFlattened, DidPaintFlattened };
 //
 class Widget : public RefCounted<Widget> {
 public:
-    explicit Widget(PlatformWidget = 0);
-    virtual ~Widget();
+    WEBCORE_EXPORT explicit Widget(PlatformWidget = nullptr);
+    WEBCORE_EXPORT virtual ~Widget();
 
-    PlatformWidget platformWidget() const;
-    void setPlatformWidget(PlatformWidget);
+    WEBCORE_EXPORT PlatformWidget platformWidget() const;
+    WEBCORE_EXPORT void setPlatformWidget(PlatformWidget);
 
     int x() const { return frameRect().x(); }
     int y() const { return frameRect().y(); }
@@ -106,8 +106,8 @@ public:
     IntSize size() const { return frameRect().size(); }
     IntPoint location() const { return frameRect().location(); }
 
-    virtual void setFrameRect(const IntRect&);
-    IntRect frameRect() const;
+    WEBCORE_EXPORT virtual void setFrameRect(const IntRect&);
+    WEBCORE_EXPORT IntRect frameRect() const;
     IntRect boundsRect() const { return IntRect(0, 0, width(),  height()); }
 
     void resize(int w, int h) { setFrameRect(IntRect(x(), y(), w, h)); }
@@ -115,16 +115,16 @@ public:
     void move(int x, int y) { setFrameRect(IntRect(x, y, width(), height())); }
     void move(const IntPoint& p) { setFrameRect(IntRect(p, size())); }
 
-    virtual void paint(GraphicsContext*, const IntRect&);
+    WEBCORE_EXPORT virtual void paint(GraphicsContext*, const IntRect&);
     void invalidate() { invalidateRect(boundsRect()); }
     virtual void invalidateRect(const IntRect&) = 0;
 
-    virtual void setFocus(bool);
+    WEBCORE_EXPORT virtual void setFocus(bool);
 
     void setCursor(const Cursor&);
 
-    virtual void show();
-    virtual void hide();
+    WEBCORE_EXPORT virtual void show();
+    WEBCORE_EXPORT virtual void hide();
     bool isSelfVisible() const { return m_selfVisible; } // Whether or not we have been explicitly marked as visible or not.
     bool isParentVisible() const { return m_parentVisible; } // Whether or not our parent is visible.
     bool isVisible() const { return m_selfVisible && m_parentVisible; } // Whether or not we are actually visible.
@@ -140,8 +140,8 @@ public:
     virtual bool isScrollbar() const { return false; }
     virtual bool isScrollView() const { return false; }
 
-    void removeFromParent();
-    virtual void setParent(ScrollView* view);
+    WEBCORE_EXPORT void removeFromParent();
+    WEBCORE_EXPORT virtual void setParent(ScrollView* view);
     ScrollView* parent() const { return m_parent; }
     ScrollView* root() const;
 
@@ -159,10 +159,10 @@ public:
     // that tries to convert the location of a rect using the point-based convertFromContainingWindow will end
     // up with an inaccurate rect.  Always make sure to use the rect-based convertFromContainingWindow method
     // when converting window rects.
-    IntRect convertToContainingWindow(const IntRect&) const;
+    WEBCORE_EXPORT IntRect convertToContainingWindow(const IntRect&) const;
     IntRect convertFromContainingWindow(const IntRect&) const;
 
-    IntPoint convertToContainingWindow(const IntPoint&) const;
+    WEBCORE_EXPORT IntPoint convertToContainingWindow(const IntPoint&) const;
     IntPoint convertFromContainingWindow(const IntPoint&) const;
 
     virtual void frameRectsChanged() { }
@@ -184,10 +184,10 @@ public:
 #endif
 
     // Virtual methods to convert points to/from the containing ScrollView
-    virtual IntRect convertToContainingView(const IntRect&) const;
-    virtual IntRect convertFromContainingView(const IntRect&) const;
-    virtual IntPoint convertToContainingView(const IntPoint&) const;
-    virtual IntPoint convertFromContainingView(const IntPoint&) const;
+    WEBCORE_EXPORT virtual IntRect convertToContainingView(const IntRect&) const;
+    WEBCORE_EXPORT virtual IntRect convertFromContainingView(const IntRect&) const;
+    WEBCORE_EXPORT virtual IntPoint convertToContainingView(const IntPoint&) const;
+    WEBCORE_EXPORT virtual IntPoint convertFromContainingView(const IntPoint&) const;
 
 private:
     void init(PlatformWidget); // Must be called by all Widget constructors to initialize cross-platform data.
index 5c5cbe3..d5e72bf 100644 (file)
@@ -34,9 +34,9 @@ namespace WebCore {
 
 typedef Vector<char, 512> URLCharBuffer;
 
-RetainPtr<CFURLRef> createCFURLFromBuffer(const char*, size_t, CFURLRef baseURL = 0);
-void getURLBytes(CFURLRef, URLCharBuffer&);
-void getURLBytes(CFURLRef, CString&);
+WEBCORE_EXPORT RetainPtr<CFURLRef> createCFURLFromBuffer(const char*, size_t, CFURLRef baseURL = 0);
+WEBCORE_EXPORT void getURLBytes(CFURLRef, URLCharBuffer&);
+WEBCORE_EXPORT void getURLBytes(CFURLRef, CString&);
 
 }
 
index fc883dd..08519e6 100644 (file)
@@ -38,12 +38,12 @@ class RunLoopObserver {
 public:
     typedef std::function<void ()> RunLoopObserverCallback;
 
-    static std::unique_ptr<RunLoopObserver> create(CFIndex order, RunLoopObserverCallback callback);
+    WEBCORE_EXPORT static std::unique_ptr<RunLoopObserver> create(CFIndex order, RunLoopObserverCallback callback);
 
-    ~RunLoopObserver();
+    WEBCORE_EXPORT ~RunLoopObserver();
 
-    void schedule(CFRunLoopRef = nullptr);
-    void invalidate();
+    WEBCORE_EXPORT void schedule(CFRunLoopRef = nullptr);
+    WEBCORE_EXPORT void invalidate();
 
     bool isScheduled() const { return m_runLoopObserver; }
 
index 5ac6dc5..a0e8962 100644 (file)
@@ -24,6 +24,6 @@
 
 namespace WebCore {
 
-NSString *systemMarketingVersion();
+WEBCORE_EXPORT NSString *systemMarketingVersion();
 
 }
index 701c6a1..3f2ded4 100644 (file)
@@ -52,11 +52,11 @@ class Color;
 
 typedef unsigned RGBA32;        // RGBA quadruplet
 
-RGBA32 makeRGB(int r, int g, int b);
-RGBA32 makeRGBA(int r, int g, int b, int a);
+WEBCORE_EXPORT RGBA32 makeRGB(int r, int g, int b);
+WEBCORE_EXPORT RGBA32 makeRGBA(int r, int g, int b, int a);
 
-RGBA32 colorWithOverrideAlpha(RGBA32 color, float overrideAlpha);
-RGBA32 makeRGBA32FromFloats(float r, float g, float b, float a);
+WEBCORE_EXPORT RGBA32 colorWithOverrideAlpha(RGBA32 color, float overrideAlpha);
+WEBCORE_EXPORT RGBA32 makeRGBA32FromFloats(float r, float g, float b, float a);
 RGBA32 makeRGBAFromHSLA(double h, double s, double l, double a);
 RGBA32 makeRGBAFromCMYKA(float c, float m, float y, float k, float a);
 
@@ -188,9 +188,9 @@ inline uint16_t fastDivideBy255(uint16_t value)
 }
 
 #if USE(CG)
-CGColorRef cachedCGColor(const Color&, ColorSpace);
+WEBCORE_EXPORT CGColorRef cachedCGColor(const Color&, ColorSpace);
 #if PLATFORM(IOS)
-CGColorRef createCGColorWithDeviceWhite(CGFloat white, CGFloat alpha);
+WEBCORE_EXPORT CGColorRef createCGColorWithDeviceWhite(CGFloat white, CGFloat alpha);
 #endif // PLATFORM(IOS)
 #endif
 
index 4f31794..8e3397d 100644 (file)
@@ -246,13 +246,13 @@ inline bool FloatRect::isInfinite() const
     return *this == infiniteRect();
 }
 
-FloatRect enclosingRectExtendedToDevicePixels(const FloatRect&, float deviceScaleFactor);
-IntRect enclosingIntRect(const FloatRect&);
+WEBCORE_EXPORT FloatRect enclosingRectExtendedToDevicePixels(const FloatRect&, float deviceScaleFactor);
+WEBCORE_EXPORT IntRect enclosingIntRect(const FloatRect&);
 
 // Returns a valid IntRect contained within the given FloatRect.
 IntRect enclosedIntRect(const FloatRect&);
 
-IntRect roundedIntRect(const FloatRect&);
+WEBCORE_EXPORT IntRect roundedIntRect(const FloatRect&);
 
 }
 
index 1b15945..8d825f2 100644 (file)
@@ -203,7 +203,7 @@ private:
 };
 
 // Get the global fontCache.
-FontCache& fontCache();
+WEBCORE_EXPORT FontCache& fontCache();
 
 class FontCachePurgePreventer {
 public:
index 83abd3c..42ac139 100644 (file)
@@ -35,10 +35,10 @@ namespace WebCore {
 float findSlope(const FloatPoint& p1, const FloatPoint& p2, float& c);
 
 // Find point where lines through the two pairs of points intersect. Returns false if the lines don't intersect.
-bool findIntersection(const FloatPoint& p1, const FloatPoint& p2, const FloatPoint& d1, const FloatPoint& d2, FloatPoint& intersection);
+WEBCORE_EXPORT bool findIntersection(const FloatPoint& p1, const FloatPoint& p2, const FloatPoint& d1, const FloatPoint& d2, FloatPoint& intersection);
 
 IntRect unionRect(const Vector<IntRect>&);
-FloatRect unionRect(const Vector<FloatRect>&);
+WEBCORE_EXPORT FloatRect unionRect(const Vector<FloatRect>&);
 
 // Map rect r from srcRect to an equivalent rect in destRect.
 FloatRect mapRect(const FloatRect&, const FloatRect& srcRect, const FloatRect& destRect);
index 79d5118..f3d47b7 100644 (file)
@@ -190,7 +190,7 @@ namespace WebCore {
     };
 
 #if PLATFORM(IOS)
-    void setStrokeAndFillColor(PlatformGraphicsContext*, CGColorRef);
+    WEBCORE_EXPORT void setStrokeAndFillColor(PlatformGraphicsContext*, CGColorRef);
 #endif
 
     struct ImagePaintingOptions {
index 107270e..1f42260 100644 (file)
@@ -226,11 +226,11 @@ inline bool operator!=(const IntRect& a, const IntRect& b)
 }
 
 #if USE(CG)
-IntRect enclosingIntRect(const CGRect&);
+WEBCORE_EXPORT IntRect enclosingIntRect(const CGRect&);
 #endif
 
 #if PLATFORM(MAC) && !defined(NSGEOMETRY_TYPES_SAME_AS_CGGEOMETRY_TYPES)
-IntRect enclosingIntRect(const NSRect&);
+WEBCORE_EXPORT IntRect enclosingIntRect(const NSRect&);
 #endif
 
 } // namespace WebCore
index 4dbf008..d12361a 100644 (file)
@@ -207,8 +207,8 @@ inline IntRect pixelSnappedIntRect(const LayoutRect& rect)
 
 }
 
-IntRect enclosingIntRect(const LayoutRect&);
-LayoutRect enclosingLayoutRect(const FloatRect&);
+WEBCORE_EXPORT IntRect enclosingIntRect(const LayoutRect&);
+WEBCORE_EXPORT LayoutRect enclosingLayoutRect(const FloatRect&);
 FloatRect enclosingRectForPainting(const LayoutRect&, float pixelSnappingFactor);
 
 inline IntRect pixelSnappedIntRect(LayoutUnit left, LayoutUnit top, LayoutUnit width, LayoutUnit height)
index 8d6716a..a033007 100644 (file)
@@ -39,16 +39,16 @@ namespace WebCore {
     public:
         enum EnableRoundingHacksOrNot { DisableRoundingHacks, EnableRoundingHacks };
 
-        static String centerTruncate(const String&, float maxWidth, const Font&, EnableRoundingHacksOrNot = DisableRoundingHacks);
-        static String rightTruncate(const String&, float maxWidth, const Font&, EnableRoundingHacksOrNot = DisableRoundingHacks);
+        WEBCORE_EXPORT static String centerTruncate(const String&, float maxWidth, const Font&, EnableRoundingHacksOrNot = DisableRoundingHacks);
+        WEBCORE_EXPORT static String rightTruncate(const String&, float maxWidth, const Font&, EnableRoundingHacksOrNot = DisableRoundingHacks);
 
-        static String centerTruncate(const String&, float maxWidth, const Font&, EnableRoundingHacksOrNot, float& resultWidth, bool shouldInsertEllipsis = true, float customTruncationElementWidth = 0);
-        static String rightTruncate(const String&, float maxWidth, const Font&, EnableRoundingHacksOrNot, float& resultWidth, bool shouldInsertEllipsis = true, float customTruncationElementWidth = 0);
-        static String leftTruncate(const String&, float maxWidth, const Font&, EnableRoundingHacksOrNot, float& resultWidth, bool shouldInsertEllipsis = true, float customTruncationElementWidth = 0);
-        static String rightClipToCharacter(const String&, float maxWidth, const Font&, EnableRoundingHacksOrNot, float& resultWidth, bool shouldInsertEllipsis = true, float customTruncationElementWidth = 0);
-        static String rightClipToWord(const String&, float maxWidth, const Font&, EnableRoundingHacksOrNot, float& resultWidth, bool shouldInsertEllipsis = true, float customTruncationElementWidth = 0, bool alwaysTruncate = false);
+        WEBCORE_EXPORT static String centerTruncate(const String&, float maxWidth, const Font&, EnableRoundingHacksOrNot, float& resultWidth, bool shouldInsertEllipsis = true, float customTruncationElementWidth = 0);
+        WEBCORE_EXPORT static String rightTruncate(const String&, float maxWidth, const Font&, EnableRoundingHacksOrNot, float& resultWidth, bool shouldInsertEllipsis = true, float customTruncationElementWidth = 0);
+        WEBCORE_EXPORT static String leftTruncate(const String&, float maxWidth, const Font&, EnableRoundingHacksOrNot, float& resultWidth, bool shouldInsertEllipsis = true, float customTruncationElementWidth = 0);
+        WEBCORE_EXPORT static String rightClipToCharacter(const String&, float maxWidth, const Font&, EnableRoundingHacksOrNot, float& resultWidth, bool shouldInsertEllipsis = true, float customTruncationElementWidth = 0);
+        WEBCORE_EXPORT static String rightClipToWord(const String&, float maxWidth, const Font&, EnableRoundingHacksOrNot, float& resultWidth, bool shouldInsertEllipsis = true, float customTruncationElementWidth = 0, bool alwaysTruncate = false);
 
-        static float width(const String&, const Font&, EnableRoundingHacksOrNot = DisableRoundingHacks);
+        WEBCORE_EXPORT static float width(const String&, const Font&, EnableRoundingHacksOrNot = DisableRoundingHacks);
     };
     
 } // namespace WebCore
index 3e1ff73..af52db4 100644 (file)
@@ -228,8 +228,8 @@ public:
     RenderingContext* renderingContext() const { return m_renderingContext.get(); }
     void setRenderingContext(PassRefPtr<RenderingContext> context) { m_renderingContext = context; }
 
-    static void setAllowsRoundingHacks(bool);
-    static bool allowsRoundingHacks();
+    WEBCORE_EXPORT static void setAllowsRoundingHacks(bool);
+    WEBCORE_EXPORT static bool allowsRoundingHacks();
 
 private:
     static bool s_allowsRoundingHacks;
index 719dfe6..0b901f9 100644 (file)
@@ -53,28 +53,28 @@ class TileController final : public TiledBacking {
     friend class TileCoverageMap;
     friend class TileGrid;
 public:
-    static PassOwnPtr<TileController> create(PlatformCALayer*);
+    WEBCORE_EXPORT static PassOwnPtr<TileController> create(PlatformCALayer*);
     ~TileController();
 
-    void tileCacheLayerBoundsChanged();
+    WEBCORE_EXPORT void tileCacheLayerBoundsChanged();
 
-    void setNeedsDisplay();
-    void setNeedsDisplayInRect(const IntRect&);
+    WEBCORE_EXPORT void setNeedsDisplay();
+    WEBCORE_EXPORT void setNeedsDisplayInRect(const IntRect&);
 
-    void setContentsScale(float);
-    float contentsScale() const;
+    WEBCORE_EXPORT void setContentsScale(float);
+    WEBCORE_EXPORT float contentsScale() const;
 
     bool acceleratesDrawing() const { return m_acceleratesDrawing; }
-    void setAcceleratesDrawing(bool);
+    WEBCORE_EXPORT void setAcceleratesDrawing(bool);
 
-    void setTilesOpaque(bool);
+    WEBCORE_EXPORT void setTilesOpaque(bool);
     bool tilesAreOpaque() const { return m_tilesAreOpaque; }
 
     PlatformCALayer& rootLayer() { return *m_tileCacheLayer; }
     const PlatformCALayer& rootLayer() const { return *m_tileCacheLayer; }
 
-    void setTileDebugBorderWidth(float);
-    void setTileDebugBorderColor(Color);
+    WEBCORE_EXPORT void setTileDebugBorderWidth(float);
+    WEBCORE_EXPORT void setTileDebugBorderColor(Color);
 
     virtual FloatRect visibleRect() const override { return m_visibleRect; }
 
@@ -122,7 +122,7 @@ public:
 
     const TileGrid& tileGrid() const { return *m_tileGrid; }
 
-    Vector<RefPtr<PlatformCALayer>> containerLayers();
+    WEBCORE_EXPORT Vector<RefPtr<PlatformCALayer>> containerLayers();
 
 protected:
     void scheduleTileRevalidation(double interval);
index eca84f0..746dcaa 100644 (file)
@@ -39,9 +39,9 @@ typedef CAPropertyAnimation* PlatformAnimationRef;
 
 namespace WebCore {
 
-NSString* toCAFillModeType(PlatformCAAnimation::FillModeType);
-NSString* toCAValueFunctionType(PlatformCAAnimation::ValueFunctionType);
-CAMediaTimingFunction* toCAMediaTimingFunction(const TimingFunction*, bool reverse);
+WEBCORE_EXPORT NSString* toCAFillModeType(PlatformCAAnimation::FillModeType);
+WEBCORE_EXPORT NSString* toCAValueFunctionType(PlatformCAAnimation::ValueFunctionType);
+WEBCORE_EXPORT CAMediaTimingFunction* toCAMediaTimingFunction(const TimingFunction*, bool reverse);
 
 bool hasExplicitBeginTime(CAAnimation *);
 void setHasExplicitBeginTime(CAAnimation *, bool);
index 780458e..179a6f3 100644 (file)
@@ -33,7 +33,7 @@ typedef struct CGColorSpace *CGColorSpaceRef;
 namespace WebCore {
 
 CGColorSpaceRef deviceRGBColorSpaceRef();
-CGColorSpaceRef sRGBColorSpaceRef();
+WEBCORE_EXPORT CGColorSpaceRef sRGBColorSpaceRef();
 CGColorSpaceRef linearRGBColorSpaceRef();
 
 static inline CGColorSpaceRef cachedCGColorSpace(ColorSpace colorSpace)
index f6ad818..74093ae 100644 (file)
@@ -40,11 +40,11 @@ namespace WebCore {
 #if USE(APPKIT)
     // These functions assume NSColors are in DeviceRGB colorspace
     Color colorFromNSColor(NSColor *);
-    NSColor *nsColor(const Color&);
+    WEBCORE_EXPORT NSColor *nsColor(const Color&);
 #endif
 
-    bool usesTestModeFocusRingColor();
-    void setUsesTestModeFocusRingColor(bool);
+    WEBCORE_EXPORT bool usesTestModeFocusRingColor();
+    WEBCORE_EXPORT void setUsesTestModeFocusRingColor(bool);
     
     // Focus ring color used for testing purposes.
     RGBA32 oldAquaFocusRingColor();
index 31f8bfd..69a6b51 100644 (file)
@@ -144,7 +144,7 @@ public:
 
     // If the matrix has 3D components, the z component of the result is
     // dropped, effectively projecting the rect into the z=0 plane.
-    FloatRect mapRect(const FloatRect&) const;
+    WEBCORE_EXPORT FloatRect mapRect(const FloatRect&) const;
 
     // Rounds the resulting mapped rectangle out. This is helpful for bounding
     // box computations but may not be what is wanted in other contexts.
@@ -219,7 +219,7 @@ public:
     // this = mat * this.
     TransformationMatrix& multiply(const TransformationMatrix&);
 
-    TransformationMatrix& scale(double);
+    WEBCORE_EXPORT TransformationMatrix& scale(double);
     TransformationMatrix& scaleNonUniform(double sx, double sy);
     TransformationMatrix& scale3d(double sx, double sy, double sz);
 
@@ -231,7 +231,7 @@ public:
     // The vector (x,y,z) is normalized if it's not already. A vector of (0,0,0) uses a vector of (0,0,1).
     TransformationMatrix& rotate3d(double x, double y, double z, double angle);
     
-    TransformationMatrix& translate(double tx, double ty);
+    WEBCORE_EXPORT TransformationMatrix& translate(double tx, double ty);
     TransformationMatrix& translate3d(double tx, double ty, double tz);
 
     // translation added with a post-multiply
@@ -254,7 +254,7 @@ public:
 
     // Returns the identity matrix if it is not invertible.
     // Use isInvertible() before calling this if you need to know.
-    TransformationMatrix inverse() const;
+    WEBCORE_EXPORT TransformationMatrix inverse() const;
 
     // Decompose the matrix into its component parts.
     struct Decomposed2Type {
@@ -348,7 +348,7 @@ public:
 
 #if USE(CA)
     TransformationMatrix(const CATransform3D&);
-    operator CATransform3D() const;
+    WEBCORE_EXPORT operator CATransform3D() const;
 #endif
 #if USE(CG)
     TransformationMatrix(const CGAffineTransform&);
index efa2f87..fd7f622 100644 (file)
@@ -30,7 +30,7 @@
 
 namespace WebCore {
 
-NSString *createTemporaryDirectory(NSString *directoryPrefix);
+WEBCORE_EXPORT NSString *createTemporaryDirectory(NSString *directoryPrefix);
 NSString *createTemporaryFile(NSString *directoryPath, NSString *filePrefix);
 
 } // namespace WebCore
index 939c89f..7c3bd11 100644 (file)
@@ -45,7 +45,7 @@ public:
 #endif
 };
 
-String keyIdentifierForKeyEvent(WebEvent *);
+WEBCORE_EXPORT String keyIdentifierForKeyEvent(WebEvent *);
 
 } // namespace WebCore
 
index 4e02a3c..7e5d69f 100644 (file)
@@ -35,11 +35,11 @@ namespace WebCore {
 class SelectionRect {
     WTF_MAKE_FAST_ALLOCATED;
 public:
-    explicit SelectionRect(const IntRect&, bool isHorizontal, int columnNumber);
+    WEBCORE_EXPORT explicit SelectionRect(const IntRect&, bool isHorizontal, int columnNumber);
 
     // FIXME: We should move some of these arguments to an auxillary struct.
     SelectionRect(const IntRect&, TextDirection, int, int, int, int, bool, bool, bool, bool, bool, bool, bool, bool, int);
-    SelectionRect();
+    WEBCORE_EXPORT SelectionRect();
     ~SelectionRect() { }
 
     IntRect rect() const { return m_rect; }
index 1f09f28..357cc31 100644 (file)
@@ -32,8 +32,8 @@
 #if TARGET_OS_IPHONE
 
 namespace WebCore {
-int systemMemoryLevel(); // In [0, 100]
-size_t systemTotalMemory();
+WEBCORE_EXPORT int systemMemoryLevel(); // In [0, 100]
+WEBCORE_EXPORT size_t systemTotalMemory();
 }
 
 #endif
index 722050c..da2fef8 100644 (file)
@@ -38,7 +38,7 @@ public:
 
     void removeTileController(TileController*);
     void tileControllerGainedUnparentedTiles(TileController*);
-    void trimUnparentedTilesToTarget(int target);
+    WEBCORE_EXPORT void trimUnparentedTilesToTarget(int target);
 
 private:
     TileControllerMemoryHandler() { }
@@ -48,7 +48,7 @@ private:
     TileControllerList m_tileControllers;
 };
 
-TileControllerMemoryHandler& tileControllerMemoryHandler();
+WEBCORE_EXPORT TileControllerMemoryHandler& tileControllerMemoryHandler();
 }
 
 #endif // TileControllerMemoryHandlerIOS_h
index 22877ba..96c9761 100644 (file)
@@ -77,27 +77,27 @@ class WebVideoFullscreenInterfaceAVKit
     void doEnterFullscreen();
         
 public:
-    WebVideoFullscreenInterfaceAVKit();
+    WEBCORE_EXPORT WebVideoFullscreenInterfaceAVKit();
     virtual ~WebVideoFullscreenInterfaceAVKit() { }
-    void setWebVideoFullscreenModel(WebVideoFullscreenModel*);
-    void setWebVideoFullscreenChangeObserver(WebVideoFullscreenChangeObserver*);
+    WEBCORE_EXPORT void setWebVideoFullscreenModel(WebVideoFullscreenModel*);
+    WEBCORE_EXPORT void setWebVideoFullscreenChangeObserver(WebVideoFullscreenChangeObserver*);
     
-    virtual void setDuration(double) override;
-    virtual void setCurrentTime(double currentTime, double anchorTime) override;
-    virtual void setRate(bool isPlaying, float playbackRate) override;
-    virtual void setVideoDimensions(bool hasVideo, float width, float height) override;
-    virtual void setSeekableRanges(const TimeRanges&) override;
-    virtual void setCanPlayFastReverse(bool) override;
-    virtual void setAudioMediaSelectionOptions(const Vector<String>& options, uint64_t selectedIndex) override;
-    virtual void setLegibleMediaSelectionOptions(const Vector<String>& options, uint64_t selectedIndex) override;
-    virtual void setExternalPlayback(bool enabled, ExternalPlaybackTargetType, String localizedDeviceName) override;
+    WEBCORE_EXPORT virtual void setDuration(double) override;
+    WEBCORE_EXPORT virtual void setCurrentTime(double currentTime, double anchorTime) override;
+    WEBCORE_EXPORT virtual void setRate(bool isPlaying, float playbackRate) override;
+    WEBCORE_EXPORT virtual void setVideoDimensions(bool hasVideo, float width, float height) override;
+    WEBCORE_EXPORT virtual void setSeekableRanges(const TimeRanges&) override;
+    WEBCORE_EXPORT virtual void setCanPlayFastReverse(bool) override;
+    WEBCORE_EXPORT virtual void setAudioMediaSelectionOptions(const Vector<String>& options, uint64_t selectedIndex) override;
+    WEBCORE_EXPORT virtual void setLegibleMediaSelectionOptions(const Vector<String>& options, uint64_t selectedIndex) override;
+    WEBCORE_EXPORT virtual void setExternalPlayback(bool enabled, ExternalPlaybackTargetType, String localizedDeviceName) override;
 
-    virtual void setupFullscreen(PlatformLayer&, WebCore::IntRect initialRect, UIView *);
-    virtual void enterFullscreen();
-    virtual void exitFullscreen(WebCore::IntRect finalRect);
-    virtual void cleanupFullscreen();
-    virtual void invalidate();
-    virtual void requestHideAndExitFullscreen();
+    WEBCORE_EXPORT virtual void setupFullscreen(PlatformLayer&, WebCore::IntRect initialRect, UIView *);
+    WEBCORE_EXPORT virtual void enterFullscreen();
+    WEBCORE_EXPORT virtual void exitFullscreen(WebCore::IntRect finalRect);
+    WEBCORE_EXPORT virtual void cleanupFullscreen();
+    WEBCORE_EXPORT virtual void invalidate();
+    WEBCORE_EXPORT virtual void requestHideAndExitFullscreen();
 };
 
 }
index aba25dc..2af20f8 100644 (file)
@@ -41,12 +41,12 @@ public:
 
 #if PLATFORM(COCOA) && defined(__OBJC__)
 // FIXME: This doesn't really belong here.
-IntPoint globalPoint(const NSPoint& windowPoint, NSWindow *);
+WEBCORE_EXPORT IntPoint globalPoint(const NSPoint& windowPoint, NSWindow *);
 
 // FIXME: WebKit2 has a lot of code copy/pasted from PlatformEventFactoryMac in WebEventFactory. It should be carefully shared with WebCore.
-int windowsKeyCodeForKeyEvent(NSEvent*);
-String keyIdentifierForKeyEvent(NSEvent*);
-double eventTimeStampSince1970(NSEvent*);
+WEBCORE_EXPORT int windowsKeyCodeForKeyEvent(NSEvent*);
+WEBCORE_EXPORT String keyIdentifierForKeyEvent(NSEvent*);
+WEBCORE_EXPORT double eventTimeStampSince1970(NSEvent*);
 
 #endif
 
index 21349a0..1499a2e 100644 (file)
@@ -65,11 +65,11 @@ public:
     static void setIsCurrentlyDrawingIntoLayer(bool);
 
 #if ENABLE(RUBBER_BANDING)
-    static void setUpOverhangAreaBackground(CALayer *, const Color& customBackgroundColor = Color());
-    static void removeOverhangAreaBackground(CALayer *);
+    WEBCORE_EXPORT static void setUpOverhangAreaBackground(CALayer *, const Color& customBackgroundColor = Color());
+    WEBCORE_EXPORT static void removeOverhangAreaBackground(CALayer *);
 
-    static void setUpOverhangAreaShadow(CALayer *);
-    static void removeOverhangAreaShadow(CALayer *);
+    WEBCORE_EXPORT static void setUpOverhangAreaShadow(CALayer *);
+    WEBCORE_EXPORT static void removeOverhangAreaShadow(CALayer *);
 #endif
 
 protected:
index 7bc3f00..e486563 100644 (file)
 
 namespace WebCore {
 
-NSString *userVisibleString(NSURL *);
-NSURL *URLByCanonicalizingURL(NSURL *);
-NSURL *URLWithUserTypedString(NSString *, NSURL *baseURL);
-NSURL *URLByRemovingUserInfo(NSURL *);
-BOOL hostNameNeedsDecodingWithRange(NSString *, NSRange);
-BOOL hostNameNeedsEncodingWithRange(NSString *, NSRange);
-NSString *decodeHostNameWithRange(NSString *, NSRange);
-NSString *encodeHostNameWithRange(NSString *, NSRange);
-NSString *decodeHostName(NSString *);
-NSString *encodeHostName(NSString *);
-NSURL *URLByTruncatingOneCharacterBeforeComponent(NSURL *, CFURLComponentType);
-NSURL *URLWithData(NSData *, NSURL *baseURL);
-NSData *originalURLData(NSURL *);
-NSData *dataForURLComponentType(NSURL *, CFURLComponentType);
+WEBCORE_EXPORT NSString *userVisibleString(NSURL *);
+WEBCORE_EXPORT NSURL *URLByCanonicalizingURL(NSURL *);
+WEBCORE_EXPORT NSURL *URLWithUserTypedString(NSString *, NSURL *baseURL);
+WEBCORE_EXPORT NSURL *URLByRemovingUserInfo(NSURL *);
+WEBCORE_EXPORT BOOL hostNameNeedsDecodingWithRange(NSString *, NSRange);
+WEBCORE_EXPORT BOOL hostNameNeedsEncodingWithRange(NSString *, NSRange);
+WEBCORE_EXPORT NSString *decodeHostNameWithRange(NSString *, NSRange);
+WEBCORE_EXPORT NSString *encodeHostNameWithRange(NSString *, NSRange);
+WEBCORE_EXPORT NSString *decodeHostName(NSString *);
+WEBCORE_EXPORT NSString *encodeHostName(NSString *);
+WEBCORE_EXPORT NSURL *URLByTruncatingOneCharacterBeforeComponent(NSURL *, CFURLComponentType);
+WEBCORE_EXPORT NSURL *URLWithData(NSData *, NSURL *baseURL);
+WEBCORE_EXPORT NSData *originalURLData(NSURL *);
+WEBCORE_EXPORT NSData *dataForURLComponentType(NSURL *, CFURLComponentType);
 
 NSRange rangeOfURLScheme(NSString *);
-BOOL isUserVisibleURL(NSString *);
-BOOL looksLikeAbsoluteURL(NSString *);
+WEBCORE_EXPORT BOOL isUserVisibleURL(NSString *);
+WEBCORE_EXPORT BOOL looksLikeAbsoluteURL(NSString *);
 
 } // namespace WebCore
index ce4cfe4..3891132 100644 (file)
@@ -25,6 +25,6 @@
 
 namespace WebCore {
 
-NSAttributedString *attributedStringByStrippingAttachmentCharacters(NSAttributedString *);
+WEBCORE_EXPORT NSAttributedString *attributedStringByStrippingAttachmentCharacters(NSAttributedString *);
 
 }
index ea29008..28e260a 100644 (file)
@@ -41,7 +41,7 @@ class BlobPart;
 class BlobRegistry;
 class URL;
 
-BlobRegistry& blobRegistry();
+WEBCORE_EXPORT BlobRegistry& blobRegistry();
 
 // BlobRegistry is not thread-safe. It should only be called from main thread.
 class BlobRegistry {
index 1c69477..9eca5ec 100644 (file)
@@ -31,8 +31,8 @@ namespace WebCore {
 // These are always observing the shared cookie storage, even when in private browsing mode.
 
 typedef void(*CookieChangeCallbackPtr)();
-void startObservingCookieChanges(CookieChangeCallbackPtr);
-void stopObservingCookieChanges();
+WEBCORE_EXPORT void startObservingCookieChanges(CookieChangeCallbackPtr);
+WEBCORE_EXPORT void stopObservingCookieChanges();
 
 }
 
index 28278e8..290f406 100644 (file)
@@ -30,7 +30,7 @@
 
 namespace WebCore {
 
-void prefetchDNS(const String& hostname);
+WEBCORE_EXPORT void prefetchDNS(const String& hostname);
 }
 
 #endif
index ce5254a..6070d0c 100644 (file)
@@ -124,7 +124,7 @@ inline bool NetworkStateNotifier::onLine() const
 }
 #endif
 
-NetworkStateNotifier& networkStateNotifier();
+WEBCORE_EXPORT NetworkStateNotifier& networkStateNotifier();
 
 } // namespace WebCore
 
index d5b89f9..43eadc0 100644 (file)
@@ -40,15 +40,15 @@ struct Cookie;
 // FIXME: These should probably be NetworkStorageSession member functions.
 
 WEBCORE_EXPORT String cookiesForDOM(const NetworkStorageSession&, const URL& firstParty, const URL&);
-void setCookiesFromDOM(const NetworkStorageSession&, const URL& firstParty, const URL&, const String&);
+WEBCORE_EXPORT void setCookiesFromDOM(const NetworkStorageSession&, const URL& firstParty, const URL&, const String&);
 bool cookiesEnabled(const NetworkStorageSession&, const URL& firstParty, const URL&);
 String cookieRequestHeaderFieldValue(const NetworkStorageSession&, const URL& firstParty, const URL&);
 bool getRawCookies(const NetworkStorageSession&, const URL& firstParty, const URL&, Vector<Cookie>&);
 void deleteCookie(const NetworkStorageSession&, const URL&, const String&);
-void getHostnamesWithCookies(const NetworkStorageSession&, HashSet<String>& hostnames);
-void deleteCookiesForHostname(const NetworkStorageSession&, const String& hostname);
-void deleteAllCookies(const NetworkStorageSession&);
-void deleteAllCookiesModifiedAfterDate(const NetworkStorageSession&, double date);
+WEBCORE_EXPORT void getHostnamesWithCookies(const NetworkStorageSession&, HashSet<String>& hostnames);
+WEBCORE_EXPORT void deleteCookiesForHostname(const NetworkStorageSession&, const String& hostname);
+WEBCORE_EXPORT void deleteAllCookies(const NetworkStorageSession&);
+WEBCORE_EXPORT void deleteAllCookiesModifiedAfterDate(const NetworkStorageSession&, double date);
 
 }
 
index 7c1914e..7e27ef4 100644 (file)
@@ -68,7 +68,7 @@ private:
 };
 
 // Return a vector of proxy servers for the given URL.
-Vector<ProxyServer> proxyServersForURL(const URL&, const NetworkingContext*);
+WEBCORE_EXPORT Vector<ProxyServer> proxyServersForURL(const URL&, const NetworkingContext*);
 
 // Converts the given vector of proxy servers to a PAC string, as described in
 // http://web.archive.org/web/20060424005037/wp.netscape.com/eng/mozilla/2.0/relnotes/demo/proxy-live.html
index 50794e4..5ae837c 100644 (file)
@@ -74,7 +74,7 @@ protected:
     {
     }
 
-    void lazyInit() const;
+    WEBCORE_EXPORT void lazyInit() const;
 
     // The ResourceError subclass may "shadow" this method to lazily initialize platform specific fields
     void platformLazyInit() {}
index 2fbf78e..5765640 100644 (file)
@@ -108,10 +108,10 @@ class ResourceHandle : public RefCounted<ResourceHandle>
 #endif
     {
 public:
-    static PassRefPtr<ResourceHandle> create(NetworkingContext*, const ResourceRequest&, ResourceHandleClient*, bool defersLoading, bool shouldContentSniff);
-    static void loadResourceSynchronously(NetworkingContext*, const ResourceRequest&, StoredCredentials, ResourceError&, ResourceResponse&, Vector<char>& data);
+    WEBCORE_EXPORT static PassRefPtr<ResourceHandle> create(NetworkingContext*, const ResourceRequest&, ResourceHandleClient*, bool defersLoading, bool shouldContentSniff);
+    WEBCORE_EXPORT static void loadResourceSynchronously(NetworkingContext*, const ResourceRequest&, StoredCredentials, ResourceError&, ResourceResponse&, Vector<char>& data);
 
-    virtual ~ResourceHandle();
+    WEBCORE_EXPORT virtual ~ResourceHandle();
 
 #if PLATFORM(COCOA) || USE(CFNETWORK)
     void willSendRequest(ResourceRequest&, const ResourceResponse& redirectResponse);
@@ -133,7 +133,7 @@ public:
 
 #if PLATFORM(COCOA) && !USE(CFNETWORK)
     void didCancelAuthenticationChallenge(const AuthenticationChallenge&);
-    NSURLConnection *connection() const;
+    WEBCORE_EXPORT NSURLConnection *connection() const;
     id makeDelegate(bool);
     id delegate();
     void releaseDelegate();
@@ -156,7 +156,7 @@ public:
 #if USE(CFNETWORK)
     CFURLStorageSessionRef storageSession() const;
     CFURLConnectionRef connection() const;
-    RetainPtr<CFURLConnectionRef> releaseConnectionForDownload();
+    WEBCORE_EXPORT RetainPtr<CFURLConnectionRef> releaseConnectionForDownload();
     const ResourceRequest& currentRequest() const;
     static void setHostAllowsAnyHTTPSCertificate(const String&);
     static void setClientCertificate(const String& host, CFDataRef);
@@ -179,7 +179,7 @@ public:
     bool shouldContentSniff() const;
     static bool shouldContentSniffURL(const URL&);
 
-    static void forceContentSniffing();
+    WEBCORE_EXPORT static void forceContentSniffing();
 
 #if USE(WININET)
     void setSynchronousInternetHandle(HINTERNET);
@@ -211,36 +211,36 @@ public:
 
     bool hasAuthenticationChallenge() const;
     void clearAuthentication();
-    virtual void cancel();
+    WEBCORE_EXPORT virtual void cancel();
 
     // The client may be 0, in which case no callbacks will be made.
     ResourceHandleClient* client() const;
-    void setClient(ResourceHandleClient*);
+    WEBCORE_EXPORT void setClient(ResourceHandleClient*);
 
     // Called in response to ResourceHandleClient::willSendRequestAsync().
-    void continueWillSendRequest(const ResourceRequest&);
+    WEBCORE_EXPORT void continueWillSendRequest(const ResourceRequest&);
 
     // Called in response to ResourceHandleClient::didReceiveResponseAsync().
-    virtual void continueDidReceiveResponse();
+    WEBCORE_EXPORT virtual void continueDidReceiveResponse();
 
 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
     // Called in response to ResourceHandleClient::canAuthenticateAgainstProtectionSpaceAsync().
-    void continueCanAuthenticateAgainstProtectionSpace(bool);
+    WEBCORE_EXPORT void continueCanAuthenticateAgainstProtectionSpace(bool);
 #endif
 
     // Called in response to ResourceHandleClient::willCacheResponseAsync().
 #if USE(CFNETWORK)
-    void continueWillCacheResponse(CFCachedURLResponseRef);
+    WEBCORE_EXPORT void continueWillCacheResponse(CFCachedURLResponseRef);
 #endif
 #if PLATFORM(COCOA) && !USE(CFNETWORK)
-    void continueWillCacheResponse(NSCachedURLResponse *);
+    WEBCORE_EXPORT void continueWillCacheResponse(NSCachedURLResponse *);
 #endif
 
-    void setDefersLoading(bool);
+    WEBCORE_EXPORT void setDefersLoading(bool);
 
     void didChangePriority(ResourceLoadPriority);
 
-    ResourceRequest& firstRequest();
+    WEBCORE_EXPORT ResourceRequest& firstRequest();
     const String& lastHTTPMethod() const;
 
     void failureTimerFired(Timer<ResourceHandle>&);
@@ -251,7 +251,7 @@ public:
     using RefCounted<ResourceHandle>::deref;
 
 #if PLATFORM(COCOA) || USE(CFNETWORK)
-    static CFStringRef synchronousLoadRunLoopMode();
+    WEBCORE_EXPORT static CFStringRef synchronousLoadRunLoopMode();
 #endif
 
 #if PLATFORM(IOS) && USE(CFNETWORK)
index 117da10..f1a9f71 100644 (file)
@@ -62,8 +62,8 @@ namespace WebCore {
     
     class ResourceHandleClient {
     public:
-        ResourceHandleClient();
-        virtual ~ResourceHandleClient();
+        WEBCORE_EXPORT ResourceHandleClient();
+        WEBCORE_EXPORT virtual ~ResourceHandleClient();
 
         // Request may be modified.
         virtual void willSendRequest(ResourceHandle*, ResourceRequest&, const ResourceResponse& /*redirectResponse*/) { }
@@ -72,7 +72,7 @@ namespace WebCore {
         virtual void didReceiveResponse(ResourceHandle*, const ResourceResponse&) { }
         
         virtual void didReceiveData(ResourceHandle*, const char*, unsigned, int /*encodedDataLength*/) { }
-        virtual void didReceiveBuffer(ResourceHandle*, PassRefPtr<SharedBuffer>, int encodedDataLength);
+        WEBCORE_EXPORT virtual void didReceiveBuffer(ResourceHandle*, PassRefPtr<SharedBuffer>, int encodedDataLength);
         
         virtual void didFinishLoading(ResourceHandle*, double /*finishTime*/) { }
         virtual void didFail(ResourceHandle*, const ResourceError&) { }
@@ -82,20 +82,20 @@ namespace WebCore {
         virtual bool usesAsyncCallbacks() { return false; }
 
         // Client will pass an updated request using ResourceHandle::continueWillSendRequest() when ready.
-        virtual void willSendRequestAsync(ResourceHandle*, const ResourceRequest&, const ResourceResponse& redirectResponse);
+        WEBCORE_EXPORT virtual void willSendRequestAsync(ResourceHandle*, const ResourceRequest&, const ResourceResponse& redirectResponse);
 
         // Client will call ResourceHandle::continueDidReceiveResponse() when ready.
-        virtual void didReceiveResponseAsync(ResourceHandle*, const ResourceResponse&);
+        WEBCORE_EXPORT virtual void didReceiveResponseAsync(ResourceHandle*, const ResourceResponse&);
 
 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
         // Client will pass an updated request using ResourceHandle::continueCanAuthenticateAgainstProtectionSpace() when ready.
-        virtual void canAuthenticateAgainstProtectionSpaceAsync(ResourceHandle*, const ProtectionSpace&);
+        WEBCORE_EXPORT virtual void canAuthenticateAgainstProtectionSpaceAsync(ResourceHandle*, const ProtectionSpace&);
 #endif
         // Client will pass an updated request using ResourceHandle::continueWillCacheResponse() when ready.
 #if USE(CFNETWORK)
-        virtual void willCacheResponseAsync(ResourceHandle*, CFCachedURLResponseRef);
+        WEBCORE_EXPORT virtual void willCacheResponseAsync(ResourceHandle*, CFCachedURLResponseRef);
 #elif PLATFORM(COCOA)
-        virtual void willCacheResponseAsync(ResourceHandle*, NSCachedURLResponse *);
+        WEBCORE_EXPORT virtual void willCacheResponseAsync(ResourceHandle*, NSCachedURLResponse *);
 #endif
 
 #if USE(NETWORK_CFDATA_ARRAY_CALLBACK)
index 90b074d..c2c134e 100644 (file)
@@ -59,28 +59,28 @@ namespace WebCore {
         // Gets a copy of the data suitable for passing to another thread.
         PassOwnPtr<CrossThreadResourceRequestData> copyData() const;
 
-        bool isNull() const;
-        bool isEmpty() const;
+        WEBCORE_EXPORT bool isNull() const;
+        WEBCORE_EXPORT bool isEmpty() const;
 
-        const URL& url() const;
-        void setURL(const URL& url);
+        WEBCORE_EXPORT const URL& url() const;
+        WEBCORE_EXPORT void setURL(const URL& url);
 
         void removeCredentials();
 
         ResourceRequestCachePolicy cachePolicy() const;
-        void setCachePolicy(ResourceRequestCachePolicy cachePolicy);
+        WEBCORE_EXPORT void setCachePolicy(ResourceRequestCachePolicy cachePolicy);
         
         double timeoutInterval() const; // May return 0 when using platform default.
         void setTimeoutInterval(double timeoutInterval);
         
-        const URL& firstPartyForCookies() const;
+        WEBCORE_EXPORT const URL& firstPartyForCookies() const;
         void setFirstPartyForCookies(const URL& firstPartyForCookies);
         
-        const String& httpMethod() const;
-        void setHTTPMethod(const String& httpMethod);
+        WEBCORE_EXPORT const String& httpMethod() const;
+        WEBCORE_EXPORT void setHTTPMethod(const String& httpMethod);
         
         const HTTPHeaderMap& httpHeaderFields() const;
-        void setHTTPHeaderFields(HTTPHeaderMap);
+        WEBCORE_EXPORT void setHTTPHeaderFields(HTTPHeaderMap);
 
         String httpHeaderField(const String& name) const;
         String httpHeaderField(HTTPHeaderName) const;
@@ -95,12 +95,12 @@ namespace WebCore {
 
         void clearHTTPAuthorization();
 
-        String httpContentType() const;
-        void setHTTPContentType(const String&);
+        WEBCORE_EXPORT String httpContentType() const;
+        WEBCORE_EXPORT void setHTTPContentType(const String&);
         void clearHTTPContentType();
 
         String httpReferrer() const;
-        void setHTTPReferrer(const String&);
+        WEBCORE_EXPORT void setHTTPReferrer(const String&);
         void clearHTTPReferrer();
         
         String httpOrigin() const;
@@ -116,10 +116,10 @@ namespace WebCore {
         void clearHTTPAccept();
 
         const Vector<String>& responseContentDispositionEncodingFallbackArray() const { return m_responseContentDispositionEncodingFallbackArray; }
-        void setResponseContentDispositionEncodingFallbackArray(const String& encoding1, const String& encoding2 = String(), const String& encoding3 = String());
+        WEBCORE_EXPORT void setResponseContentDispositionEncodingFallbackArray(const String& encoding1, const String& encoding2 = String(), const String& encoding3 = String());
 
-        FormData* httpBody() const;
-        void setHTTPBody(PassRefPtr<FormData> httpBody);
+        WEBCORE_EXPORT FormData* httpBody() const;
+        WEBCORE_EXPORT void setHTTPBody(PassRefPtr<FormData> httpBody);
         
         bool allowCookies() const;
         void setAllowCookies(bool allowCookies);
@@ -155,12 +155,12 @@ namespace WebCore {
         template<class Encoder> void encodeWithoutPlatformData(Encoder&) const;
         template<class Decoder> bool decodeWithoutPlatformData(Decoder&);
 
-        static double defaultTimeoutInterval(); // May return 0 when using platform default.
-        static void setDefaultTimeoutInterval(double);
+        WEBCORE_EXPORT static double defaultTimeoutInterval(); // May return 0 when using platform default.
+        WEBCORE_EXPORT static void setDefaultTimeoutInterval(double);
 
 #if PLATFORM(IOS)
-        static bool defaultAllowCookies();
-        static void setDefaultAllowCookies(bool);
+        WEBCORE_EXPORT static bool defaultAllowCookies();
+        WEBCORE_EXPORT static void setDefaultAllowCookies(bool);
 #endif
 
         static bool compare(const ResourceRequest&, const ResourceRequest&);
@@ -236,7 +236,7 @@ namespace WebCore {
     private:
         const ResourceRequest& asResourceRequest() const;
 
-        static double s_defaultTimeoutInterval;
+        WEBCORE_EXPORT static double s_defaultTimeoutInterval;
 #if PLATFORM(IOS)
         static bool s_defaultAllowCookies;
 #endif
@@ -267,7 +267,7 @@ namespace WebCore {
     
     unsigned initializeMaximumHTTPConnectionCountPerHost();
 #if PLATFORM(IOS)
-    void initializeHTTPConnectionSettingsOnStartup();
+    WEBCORE_EXPORT void initializeHTTPConnectionSettingsOnStartup();
 #endif
 
 template<class Encoder>
index d124849..4f4a211 100644 (file)
@@ -53,36 +53,36 @@ public:
     PassOwnPtr<CrossThreadResourceResponseData> copyData() const;
 
     bool isNull() const { return m_isNull; }
-    bool isHTTP() const;
+    WEBCORE_EXPORT bool isHTTP() const;
 
-    const URL& url() const;
-    void setURL(const URL& url);
+    WEBCORE_EXPORT const URL& url() const;
+    WEBCORE_EXPORT void setURL(const URL& url);
 
-    const String& mimeType() const;
-    void setMimeType(const String& mimeType);
+    WEBCORE_EXPORT const String& mimeType() const;
+    WEBCORE_EXPORT void setMimeType(const String& mimeType);
 
-    long long expectedContentLength() const;
-    void setExpectedContentLength(long long expectedContentLength);
+    WEBCORE_EXPORT long long expectedContentLength() const;
+    WEBCORE_EXPORT void setExpectedContentLength(long long expectedContentLength);
 
-    const String& textEncodingName() const;
-    void setTextEncodingName(const String& name);
+    WEBCORE_EXPORT const String& textEncodingName() const;
+    WEBCORE_EXPORT void setTextEncodingName(const String& name);
 
     // FIXME: Should compute this on the fly.
     // There should not be a setter exposed, as suggested file name is determined based on other headers in a manner that WebCore does not necessarily know about.
-    const String& suggestedFilename() const;
-    void setSuggestedFilename(const String&);
+    WEBCORE_EXPORT const String& suggestedFilename() const;
+    WEBCORE_EXPORT void setSuggestedFilename(const String&);
 
-    int httpStatusCode() const;
-    void setHTTPStatusCode(int);
+    WEBCORE_EXPORT int httpStatusCode() const;
+    WEBCORE_EXPORT void setHTTPStatusCode(int);
     
-    const String& httpStatusText() const;
-    void setHTTPStatusText(const String&);
+    WEBCORE_EXPORT const String& httpStatusText() const;
+    WEBCORE_EXPORT void setHTTPStatusText(const String&);
 
-    const HTTPHeaderMap& httpHeaderFields() const;
+    WEBCORE_EXPORT const HTTPHeaderMap& httpHeaderFields() const;
 
     String httpHeaderField(const String& name) const;
-    String httpHeaderField(HTTPHeaderName) const;
-    void setHTTPHeaderField(const String& name, const String& value);
+    WEBCORE_EXPORT String httpHeaderField(HTTPHeaderName) const;
+    WEBCORE_EXPORT void setHTTPHeaderField(const String& name, const String& value);
     void setHTTPHeaderField(HTTPHeaderName, const String& value);
 
     void addHTTPHeaderField(const String& name, const String& value);
@@ -94,7 +94,7 @@ public:
 
     bool isMultipart() const { return mimeType() == "multipart/x-mixed-replace"; }
 
-    bool isAttachment() const;
+    WEBCORE_EXPORT bool isAttachment() const;
     
     // These functions return parsed values of the corresponding response headers.
     // NaN means that the header was not present or had invalid value.
@@ -106,7 +106,7 @@ public:
     double date() const;
     double age() const;
     double expires() const;
-    double lastModified() const;
+    WEBCORE_EXPORT double lastModified() const;
 
     unsigned connectionID() const;
     void setConnectionID(unsigned);
@@ -136,7 +136,7 @@ protected:
         AllFields
     };
 
-    ResourceResponseBase();
+    WEBCORE_EXPORT ResourceResponseBase();
     ResourceResponseBase(const URL& url, const String& mimeType, long long expectedLength, const String& textEncodingName, const String& filename);
 
     void lazyInit(InitLevel) const;
index 4619f8f..09093d7 100644 (file)
@@ -47,7 +47,7 @@ public:
     const ResourceError& error() const { return m_error; }
     bool isDone() { return m_isDone; }
 
-    static ResourceError platformBadResponseError();
+    WEBCORE_EXPORT static ResourceError platformBadResponseError();
 
 private:
     SynchronousLoaderClient()
index 839be96..1703cc9 100644 (file)
@@ -56,10 +56,10 @@ public:
     {
     }
 
-    ResourceError(CFErrorRef error);
+    WEBCORE_EXPORT ResourceError(CFErrorRef error);
 
-    CFErrorRef cfError() const;
-    operator CFErrorRef() const;
+    WEBCORE_EXPORT CFErrorRef cfError() const;
+    WEBCORE_EXPORT operator CFErrorRef() const;
 
 #if USE(CFNETWORK)
 #if PLATFORM(WIN)
@@ -73,9 +73,9 @@ public:
 #endif
 
 #if PLATFORM(COCOA)
-    ResourceError(NSError *);
-    NSError *nsError() const;
-    operator NSError *() const;
+    WEBCORE_EXPORT ResourceError(NSError *);
+    WEBCORE_EXPORT NSError *nsError() const;
+    WEBCORE_EXPORT operator NSError *() const;
 #endif
 
     static bool platformCompare(const ResourceError& a, const ResourceError& b);
index c07404b..8c4ae0d 100644 (file)
@@ -64,7 +64,7 @@ namespace WebCore {
         
 #if USE(CFNETWORK)
 #if PLATFORM(COCOA)
-        ResourceRequest(NSURLRequest *);
+        WEBCORE_EXPORT ResourceRequest(NSURLRequest *);
         void updateNSURLRequest();
         void clearOrUpdateNSURLRequest();
 #endif
@@ -82,7 +82,7 @@ namespace WebCore {
         }
 #endif
 
-        void updateFromDelegatePreservingOldProperties(const ResourceRequest&);
+        WEBCORE_EXPORT void updateFromDelegatePreservingOldProperties(const ResourceRequest&);
 
 #if PLATFORM(MAC)
         void applyWebArchiveHackForMail();
@@ -93,22 +93,22 @@ namespace WebCore {
 #else
         bool encodingRequiresPlatformData() const { return m_httpBody || m_nsRequest; }
 #endif
-        NSURLRequest *nsURLRequest(HTTPBodyUpdatePolicy) const;
+        WEBCORE_EXPORT NSURLRequest *nsURLRequest(HTTPBodyUpdatePolicy) const;
 #endif
 
 #if ENABLE(CACHE_PARTITIONING)
-        static String partitionName(const String& domain);
+        WEBCORE_EXPORT static String partitionName(const String& domain);
         const String& cachePartition() const { return m_cachePartition.isNull() ? emptyString() : m_cachePartition; }
         void setCachePartition(const String& cachePartition) { m_cachePartition = partitionName(cachePartition); }
 #endif
 
 #if PLATFORM(COCOA) || USE(CFNETWORK)
-        CFURLRequestRef cfURLRequest(HTTPBodyUpdatePolicy) const;
+        WEBCORE_EXPORT CFURLRequestRef cfURLRequest(HTTPBodyUpdatePolicy) const;
         void setStorageSession(CFURLStorageSessionRef);
 #endif
 
-        static bool httpPipeliningEnabled();
-        static void setHTTPPipeliningEnabled(bool);
+        WEBCORE_EXPORT static bool httpPipeliningEnabled();
+        WEBCORE_EXPORT static void setHTTPPipeliningEnabled(bool);
 
         static bool resourcePrioritiesEnabled();
 
index 8c5f570..776398c 100644 (file)
@@ -54,7 +54,7 @@ public:
         m_isNull = !cfResponse;
     }
 #if PLATFORM(COCOA)
-    ResourceResponse(NSURLResponse *);
+    WEBCORE_EXPORT ResourceResponse(NSURLResponse *);
 #endif
 #else
     ResourceResponse(NSURLResponse *nsResponse)
@@ -86,15 +86,15 @@ public:
     }
 
 #if USE(CFNETWORK)
-    CFURLResponseRef cfURLResponse() const;
+    WEBCORE_EXPORT CFURLResponseRef cfURLResponse() const;
 #endif
 #if PLATFORM(COCOA)
-    NSURLResponse *nsURLResponse() const;
+    WEBCORE_EXPORT NSURLResponse *nsURLResponse() const;
 #endif
 
 #if PLATFORM(COCOA) || USE(CFNETWORK)
-    void setCertificateChain(CFArrayRef);
-    RetainPtr<CFArrayRef> certificateChain() const;
+    WEBCORE_EXPORT void setCertificateChain(CFArrayRef);
+    WEBCORE_EXPORT RetainPtr<CFArrayRef> certificateChain() const;
 #endif
 
     bool platformResponseIsUpToDate() const { return m_platformResponseIsUpToDate; }
index f52401c..b23b0e9 100644 (file)
@@ -66,18 +66,18 @@ NSSet *QLPreviewGetSupportedMIMETypesSet();
 NSDictionary *QLFileAttributes();
 NSDictionary *QLDirectoryAttributes();
 
-void addQLPreviewConverterWithFileForURL(NSURL *, id converter, NSString *fileName);
-NSString *qlPreviewConverterFileNameForURL(NSURL *);
-NSString *qlPreviewConverterUTIForURL(NSURL *);
-void removeQLPreviewConverterForURL(NSURL *);
+WEBCORE_EXPORT void addQLPreviewConverterWithFileForURL(NSURL *, id converter, NSString *fileName);
+WEBCORE_EXPORT NSString *qlPreviewConverterFileNameForURL(NSURL *);
+WEBCORE_EXPORT NSString *qlPreviewConverterUTIForURL(NSURL *);
+WEBCORE_EXPORT void removeQLPreviewConverterForURL(NSURL *);
 
-PassOwnPtr<ResourceRequest> registerQLPreviewConverterIfNeeded(NSURL *, NSString *mimeType, NSData *);
+WEBCORE_EXPORT PassOwnPtr<ResourceRequest> registerQLPreviewConverterIfNeeded(NSURL *, NSString *mimeType, NSData *);
 
 const URL safeQLURLForDocumentURLAndResourceURL(const URL& documentURL, const String& resourceURL);
 
 const char* QLPreviewProtocol();
 
-NSString *createTemporaryFileForQuickLook(NSString *fileName);
+WEBCORE_EXPORT NSString *createTemporaryFileForQuickLook(NSString *fileName);
 
 class QuickLookHandle {
     WTF_MAKE_NONCOPYABLE(QuickLookHandle);
index 44867f7..677278c 100644 (file)
@@ -33,9 +33,9 @@ namespace WebCore {
 
 class AuthenticationChallenge;
 
-NSURLAuthenticationChallenge *mac(const AuthenticationChallenge&);
+WEBCORE_EXPORT NSURLAuthenticationChallenge *mac(const AuthenticationChallenge&);
 
-AuthenticationChallenge core(NSURLAuthenticationChallenge *);
+WEBCORE_EXPORT AuthenticationChallenge core(NSURLAuthenticationChallenge *);
 
 }
 #endif // __OBJC__
index 4cdbb8b..e150855 100644 (file)
 
 namespace WebCore {
 
-const int SQLResultDone = SQLITE_DONE;
+WEBCORE_EXPORT const int SQLResultDone = SQLITE_DONE;
 const int SQLResultError = SQLITE_ERROR;
-const int SQLResultOk = SQLITE_OK;
-const int SQLResultRow = SQLITE_ROW;
+WEBCORE_EXPORT const int SQLResultOk = SQLITE_OK;
+WEBCORE_EXPORT const int SQLResultRow = SQLITE_ROW;
 const int SQLResultSchema = SQLITE_SCHEMA;
 const int SQLResultFull = SQLITE_FULL;
 const int SQLResultInterrupt = SQLITE_INTERRUPT;
-const int SQLResultConstraint = SQLITE_CONSTRAINT;
+WEBCORE_EXPORT const int SQLResultConstraint = SQLITE_CONSTRAINT;
 
 static const char notOpenErrorMessage[] = "database is not open";
 
index 4ff8698..73006d2 100644 (file)
@@ -37,7 +37,7 @@
 namespace WebCore {
 
 UScriptCode localeToScriptCodeForFontSelection(const String&);
-UScriptCode scriptNameToCode(const String&);
+WEBCORE_EXPORT UScriptCode scriptNameToCode(const String&);
 
 }
 
index 1179372..880fbf2 100644 (file)
@@ -40,8 +40,8 @@ TextBreakIterator* cursorMovementIterator(StringView);
 TextBreakIterator* wordBreakIterator(StringView);
 TextBreakIterator* sentenceBreakIterator(StringView);
 
-TextBreakIterator* acquireLineBreakIterator(StringView, const AtomicString& locale, const UChar* priorContext, unsigned priorContextLength);
-void releaseLineBreakIterator(TextBreakIterator*);
+WEBCORE_EXPORT TextBreakIterator* acquireLineBreakIterator(StringView, const AtomicString& locale, const UChar* priorContext, unsigned priorContextLength);
+WEBCORE_EXPORT void releaseLineBreakIterator(TextBreakIterator*);
 
 int textBreakFirst(TextBreakIterator*);
 int textBreakLast(TextBreakIterator*);
@@ -49,7 +49,7 @@ int textBreakNext(TextBreakIterator*);
 int textBreakPrevious(TextBreakIterator*);
 int textBreakCurrent(TextBreakIterator*);
 int textBreakPreceding(TextBreakIterator*, int);
-int textBreakFollowing(TextBreakIterator*, int);
+WEBCORE_EXPORT int textBreakFollowing(TextBreakIterator*, int);
 bool isTextBreak(TextBreakIterator*, int);
 bool isWordTextBreak(TextBreakIterator*);
 
index c9cf6c2..010d3d2 100644 (file)
@@ -35,7 +35,7 @@ namespace WebCore {
     public:
         TextEncoding() : m_name(0) { }
         TextEncoding(const char* name);
-        TextEncoding(const String& name);
+        WEBCORE_EXPORT TextEncoding(const String& name);
 
         bool isValid() const { return m_name; }
         const char* name() const { return m_name; }
@@ -63,7 +63,7 @@ namespace WebCore {
         const TextEncoding& closestByteBasedEquivalent() const;
         const TextEncoding& encodingForFormSubmission() const;
 
-        String decode(const char* str, size_t length) const
+        WEBCORE_EXPORT String decode(const char* str, size_t length) const
         {
             bool ignored;
             return decode(str, length, false, ignored);
@@ -90,8 +90,8 @@ namespace WebCore {
     const TextEncoding& UTF16LittleEndianEncoding();
     const TextEncoding& UTF32BigEndianEncoding();
     const TextEncoding& UTF32LittleEndianEncoding();
-    const TextEncoding& UTF8Encoding();
-    const TextEncoding& WindowsLatin1Encoding();
+    WEBCORE_EXPORT const TextEncoding& UTF8Encoding();
+    WEBCORE_EXPORT const TextEncoding& WindowsLatin1Encoding();
 
 } // namespace WebCore
 
index 928b4d1..ec0463b 100644 (file)
@@ -48,7 +48,7 @@ namespace WebCore {
     bool isJapaneseEncoding(const char* canonicalEncodingName);
     bool shouldShowBackslashAsCurrencySymbolIn(const char* canonicalEncodingName);
 
-    String defaultTextEncodingNameForSystemLanguage();
+    WEBCORE_EXPORT String defaultTextEncodingNameForSystemLanguage();
 
 #ifndef NDEBUG
     void dumpTextEncodingNameMap();
index 64cac40..8fec114 100644 (file)
@@ -46,24 +46,24 @@ public:
         double value;
     };
 
-    TextStream& operator<<(bool);
-    TextStream& operator<<(int);
-    TextStream& operator<<(unsigned);
+    WEBCORE_EXPORT TextStream& operator<<(bool);
+    WEBCORE_EXPORT TextStream& operator<<(int);
+    WEBCORE_EXPORT TextStream& operator<<(unsigned);
     TextStream& operator<<(long);
     TextStream& operator<<(unsigned long);
     TextStream& operator<<(long long);
-    TextStream& operator<<(unsigned long long);
-    TextStream& operator<<(float);
-    TextStream& operator<<(double);
-    TextStream& operator<<(const char*);
-    TextStream& operator<<(const void*);
-    TextStream& operator<<(const String&);
+    WEBCORE_EXPORT TextStream& operator<<(unsigned long long);
+    WEBCORE_EXPORT TextStream& operator<<(float);
+    WEBCORE_EXPORT TextStream& operator<<(double);
+    WEBCORE_EXPORT TextStream& operator<<(const char*);
+    WEBCORE_EXPORT TextStream& operator<<(const void*);
+    WEBCORE_EXPORT TextStream& operator<<(const String&);
     TextStream& operator<<(const FormatNumberRespectingIntegers&);
 
-    TextStream& operator<<(const IntPoint&);
-    TextStream& operator<<(const IntRect&);
-    TextStream& operator<<(const FloatPoint&);
-    TextStream& operator<<(const FloatSize&);
+    WEBCORE_EXPORT TextStream& operator<<(const IntPoint&);
+    WEBCORE_EXPORT TextStream& operator<<(const IntRect&);
+    WEBCORE_EXPORT TextStream& operator<<(const FloatPoint&);
+    WEBCORE_EXPORT TextStream& operator<<(const FloatSize&);
     TextStream& operator<<(const LayoutUnit&);
     TextStream& operator<<(const LayoutPoint&);
     TextStream& operator<<(const LayoutRect&);
@@ -83,7 +83,7 @@ public:
         return *this << "]";
     }
 
-    String release();
+    WEBCORE_EXPORT String release();
 
 private:
     StringBuilder m_text;
index 4f69227..a0863bd 100644 (file)
@@ -187,7 +187,7 @@ public:
 
     virtual RenderBoxModelObject* virtualContinuation() const override final { return continuation(); }
     bool isAnonymousBlockContinuation() const { return isAnonymousBlock() && continuation(); }
-    RenderInline* inlineElementContinuation() const;
+    WEBCORE_EXPORT RenderInline* inlineElementContinuation() const;
     RenderBlock* blockElementContinuation() const;
 
     using RenderBoxModelObject::continuation;
index 5bcf624..70858ac 100644 (file)
@@ -163,7 +163,7 @@ public:
     IntRect pixelSnappedBorderBoxRect() const { return IntRect(IntPoint(), m_frameRect.pixelSnappedSize()); }
     virtual IntRect borderBoundingBox() const override final { return pixelSnappedBorderBoxRect(); }
 
-    RoundedRect::Radii borderRadii() const;
+    WEBCORE_EXPORT RoundedRect::Radii borderRadii() const;
 
     // The content area of the box (excludes padding - and intrinsic padding for table cells, etc... - and border).
     LayoutRect contentBoxRect() const { return LayoutRect(borderLeft() + paddingLeft(), borderTop() + paddingTop(), contentWidth(), contentHeight()); }
@@ -189,7 +189,7 @@ public:
     // For horizontal-tb and vertical-lr they will match physical directions, but for horizontal-bt and vertical-rl, the top/bottom and left/right
     // respectively are flipped when compared to their physical counterparts.  For example minX is on the left in vertical-lr,
     // but it is on the right in vertical-rl.
-    LayoutRect flippedClientBoxRect() const;
+    WEBCORE_EXPORT LayoutRect flippedClientBoxRect() const;
     LayoutRect layoutOverflowRect() const { return m_overflow ? m_overflow->layoutOverflowRect() : flippedClientBoxRect(); }
     LayoutUnit logicalLeftLayoutOverflow() const { return style().isHorizontalWritingMode() ? layoutOverflowRect().x() : layoutOverflowRect().y(); }
     LayoutUnit logicalRightLayoutOverflow() const { return style().isHorizontalWritingMode() ? layoutOverflowRect().maxX() : layoutOverflowRect().maxY(); }
@@ -231,8 +231,8 @@ public:
     // excluding border and scrollbar.  clientLeft/Top are just the borderLeftWidth and borderTopWidth.
     LayoutUnit clientLeft() const { return borderLeft(); }
     LayoutUnit clientTop() const { return borderTop(); }
-    LayoutUnit clientWidth() const;
-    LayoutUnit clientHeight() const;
+    WEBCORE_EXPORT LayoutUnit clientWidth() const;
+    WEBCORE_EXPORT LayoutUnit clientHeight() const;
     LayoutUnit clientLogicalWidth() const { return style().isHorizontalWritingMode() ? clientWidth() : clientHeight(); }
     LayoutUnit clientLogicalHeight() const { return style().isHorizontalWritingMode() ? clientHeight() : clientWidth(); }
     LayoutUnit clientLogicalBottom() const { return borderBefore() + clientLogicalHeight(); }
index d738804..07ff841 100644 (file)
@@ -46,17 +46,17 @@ public:
         PluginBlockedByContentSecurityPolicy,
         InsecurePluginVersion,
     };
-    void setPluginUnavailabilityReason(PluginUnavailabilityReason);
-    void setPluginUnavailabilityReasonWithDescription(PluginUnavailabilityReason, const String& description);
+    WEBCORE_EXPORT void setPluginUnavailabilityReason(PluginUnavailabilityReason);
+    WEBCORE_EXPORT void setPluginUnavailabilityReasonWithDescription(PluginUnavailabilityReason, const String& description);
 
     bool isPluginUnavailable() const { return m_isPluginUnavailable; }
     bool showsUnavailablePluginIndicator() const { return isPluginUnavailable() && !m_isUnavailablePluginIndicatorHidden; }
 
-    void setUnavailablePluginIndicatorIsHidden(bool);
+    WEBCORE_EXPORT void setUnavailablePluginIndicatorIsHidden(bool);
 
     void handleUnavailablePluginIndicatorEvent(Event*);
 
-    bool isReplacementObscured() const;
+    WEBCORE_EXPORT bool isReplacementObscured() const;
 
     bool allowsAcceleratedCompositing() const;
 
index bd261a7..9c4898c 100644 (file)
@@ -739,7 +739,7 @@ public:
     // Bounding box in the coordinates of this layer.
     LayoutRect localBoundingBox(CalculateLayerBoundsFlags = 0) const;
     // Deprecated: Pixel snapped bounding box relative to the root.
-    IntRect absoluteBoundingBox() const;
+    WEBCORE_EXPORT IntRect absoluteBoundingBox() const;
     // Device pixel snapped bounding box relative to the root. absoluteBoundingBox() callers will be directed to this.
     FloatRect absoluteBoundingBoxForPainting() const;
 
@@ -832,7 +832,7 @@ public:
     virtual GraphicsLayer* layerForVerticalScrollbar() const override;
     virtual GraphicsLayer* layerForScrollCorner() const override;
     virtual bool usesCompositedScrolling() const override;
-    bool needsCompositedScrolling() const;
+    WEBCORE_EXPORT bool needsCompositedScrolling() const;
     bool needsCompositingLayersRebuiltForClip(const RenderStyle* oldStyle, const RenderStyle* newStyle) const;
     bool needsCompositingLayersRebuiltForOverflow(const RenderStyle* oldStyle, const RenderStyle* newStyle) const;
 
index 69722f9..cf908ac 100644 (file)
@@ -185,7 +185,7 @@ public:
     bool hasUnpositionedOverflowControlsLayers() const;
 
     bool usingTiledBacking() const { return m_usingTiledCacheLayer; }
-    TiledBacking* tiledBacking() const;
+    WEBCORE_EXPORT TiledBacking* tiledBacking() const;
     void adjustTiledBackingCoverage();
     void setTiledBackingHasMargins(bool hasExtendedBackgroundOnLeftAndRight, bool hasExtendedBackgroundOnTopAndBottom);
     
@@ -222,10 +222,10 @@ public:
     virtual void verifyNotPainting();
 #endif
 
-    LayoutRect contentsBox() const;
+    WEBCORE_EXPORT LayoutRect contentsBox() const;
     
     // For informative purposes only.
-    CompositingLayerType compositingLayerType() const;
+    WEBCORE_EXPORT CompositingLayerType compositingLayerType() const;
     
     GraphicsLayer* layerForHorizontalScrollbar() const { return m_layerForHorizontalScrollbar.get(); }
     GraphicsLayer* layerForVerticalScrollbar() const { return m_layerForVerticalScrollbar.get(); }
index 2ffc68b..a867579 100644 (file)
@@ -178,9 +178,9 @@ public:
     // Returns true if the given layer needs it own backing store.
     bool requiresOwnBackingStore(const RenderLayer&, const RenderLayer* compositingAncestorLayer, const LayoutRect& layerCompositedBoundsInAncestor, const LayoutRect& ancestorCompositedBounds) const;
 
-    RenderLayer& rootRenderLayer() const;
+    WEBCORE_EXPORT RenderLayer& rootRenderLayer() const;
     GraphicsLayer* rootGraphicsLayer() const;
-    GraphicsLayer* scrollLayer() const;
+    WEBCORE_EXPORT GraphicsLayer* scrollLayer() const;
     GraphicsLayer* clipLayer() const;
     GraphicsLayer* rootContentLayer() const;
 
index 035991a..d2e38bd 100644 (file)
@@ -47,7 +47,7 @@ public:
     void setNotInList(bool notInList) { m_notInList = notInList; }
     bool notInList() const { return m_notInList; }
 
-    const String& markerText() const;
+    WEBCORE_EXPORT const String& markerText() const;
     String markerTextWithSuffix() const;
 
     void updateListMarkerNumbers();
index c34ae36..fea9548 100644 (file)
@@ -172,7 +172,7 @@ public:
     RenderObject* nextInPreOrderAfterChildren(const RenderObject* stayWithin) const;
     RenderObject* previousInPreOrder() const;
     RenderObject* previousInPreOrder(const RenderObject* stayWithin) const;
-    RenderObject* childAt(unsigned) const;
+    WEBCORE_EXPORT RenderObject* childAt(unsigned) const;
 
     RenderObject* firstLeafChild() const;
     RenderObject* lastLeafChild() const;
@@ -197,13 +197,13 @@ public:
     RenderObject* traverseNext(const RenderObject* stayWithin, HeightTypeTraverseNextInclusionFunction, int& currentDepth,  int& newFixedDepth) const;
 
     void adjustComputedFontSizesOnBlocks(float size, float visibleWidth);
-    void resetTextAutosizing();
+    WEBCORE_EXPORT void resetTextAutosizing();
 #endif
 
-    RenderLayer* enclosingLayer() const;
+    WEBCORE_EXPORT RenderLayer* enclosingLayer() const;
 
     // Scrolling is a RenderBox concept, however some code just cares about recursively scrolling our enclosing ScrollableArea(s).
-    bool scrollRectToVisible(const LayoutRect&, const ScrollAlignment& alignX = ScrollAlignment::alignCenterIfNeeded, const ScrollAlignment& alignY = ScrollAlignment::alignCenterIfNeeded);
+    WEBCORE_EXPORT bool scrollRectToVisible(const LayoutRect&, const ScrollAlignment& alignX = ScrollAlignment::alignCenterIfNeeded, const ScrollAlignment& alignY = ScrollAlignment::alignCenterIfNeeded);
 
     // Convenience function for getting to the nearest enclosing box of a RenderObject.
     RenderBox& enclosingBox() const;
@@ -669,7 +669,7 @@ public:
 
     // Convert the given local point to absolute coordinates
     // FIXME: Temporary. If UseTransforms is&nbs